@luma.gl/engine 9.0.0-beta.3 → 9.0.0-beta.5

package/dist/geometry/geometry-utils.js

@@ -1,37 +1,40 @@
+// import type {Geometry} from './geometry';
 export function unpackIndexedGeometry(geometry) {
-  const {
-    indices,
-    attributes
-  } = geometry;
-  if (!indices) {
-    return geometry;
-  }
-  const vertexCount = indices.value.length;
-  const unpackedAttributes = {};
-  for (const attributeName in attributes) {
-    const attribute = attributes[attributeName];
-    const {
-      constant,
-      value,
-      size
-    } = attribute;
-    if (constant || !size) {
-      continue;
+    const { indices, attributes } = geometry;
+    if (!indices) {
+        return geometry;
     }
-    const unpackedValue = new value.constructor(vertexCount * size);
-    for (let x = 0; x < vertexCount; ++x) {
-      const index = indices.value[x];
-      for (let i = 0; i < size; i++) {
-        unpackedValue[x * size + i] = value[index * size + i];
-      }
+    const vertexCount = indices.value.length;
+    const unpackedAttributes = {};
+    for (const attributeName in attributes) {
+        const attribute = attributes[attributeName];
+        const { constant, value, size } = attribute;
+        if (constant || !size) {
+            continue; // eslint-disable-line
+        }
+        const unpackedValue = new value.constructor(vertexCount * size);
+        for (let x = 0; x < vertexCount; ++x) {
+            const index = indices.value[x];
+            for (let i = 0; i < size; i++) {
+                unpackedValue[x * size + i] = value[index * size + i];
+            }
+        }
+        unpackedAttributes[attributeName] = { size, value: unpackedValue };
     }
-    unpackedAttributes[attributeName] = {
-      size,
-      value: unpackedValue
+    return {
+        attributes: Object.assign({}, attributes, unpackedAttributes)
     };
-  }
-  return {
-    attributes: Object.assign({}, attributes, unpackedAttributes)
-  };
 }
-//# sourceMappingURL=geometry-utils.js.map
+// export function calculateVertexNormals(positions: Float32Array): Uint8Array {
+//   let normals = new Uint8Array(positions.length / 3);
+//   for (let i = 0; i < positions.length; i++) {
+//     const vec1 = new Vector3(positions.subarray(i * 3, i + 0, i + 3));
+//     const vec2 = new Vector3(positions.subarray(i + 3, i + 6));
+//     const vec3 = new Vector3(positions.subarray(i + 6, i + 9));
+//     const normal = new Vector3(vec1).cross(vec2).normalize();
+//     normals.set(normal[0], i + 4);
+//     normals.set(normal[1], i + 4 + 1);
+//     normals.set(normal[2], i + 2);
+//   }
+//   const normal = new Vector3(vec1).cross(vec2).normalize();
+// }

package/dist/geometry/geometry.js

@@ -1,79 +1,85 @@
 import { uid, assert } from '@luma.gl/core';
 export class Geometry {
-  constructor(props) {
-    this.id = void 0;
-    this.topology = void 0;
-    this.vertexCount = void 0;
-    this.indices = void 0;
-    this.attributes = void 0;
-    this.userData = {};
-    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;
+    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), `${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);
-  }
-  getVertexCount() {
-    return this.vertexCount;
-  }
-  getAttributes() {
-    return this.indices ? {
-      indices: this.indices,
-      ...this.attributes
-    } : this.attributes;
-  }
-  _print(attributeName) {
-    return `Geometry ${this.id} attribute ${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 attribute of Object.values(attributes)) {
-      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;
-  }
 }
-//# sourceMappingURL=geometry.js.map

package/dist/geometry/gpu-geometry.js

@@ -1,110 +1,91 @@
 import { Buffer, uid, assert, getVertexFormatFromAttribute } from '@luma.gl/core';
 export class GPUGeometry {
-  constructor(props) {
-    this.id = void 0;
-    this.userData = {};
-    this.topology = void 0;
-    this.bufferLayout = [];
-    this.vertexCount = void 0;
-    this.indices = void 0;
-    this.attributes = void 0;
-    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);
+    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();
+        this.attributes.positions.destroy();
+        this.attributes.normals.destroy();
+        this.attributes.texCoords.destroy();
+        this.attributes.colors?.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;
     }
-  }
-  destroy() {
-    var _this$attributes$colo;
-    this.indices.destroy();
-    this.attributes.positions.destroy();
-    this.attributes.normals.destroy();
-    this.attributes.texCoords.destroy();
-    (_this$attributes$colo = this.attributes.colors) === null || _this$attributes$colo === void 0 ? void 0 : _this$attributes$colo.destroy();
-  }
-  getVertexCount() {
-    return this.vertexCount;
-  }
-  getAttributes() {
-    return this.attributes;
-  }
-  getIndexes() {
-    return this.indices;
-  }
-  _calculateVertexCount(positions) {
-    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
-  });
+    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
-  });
+    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;
-    switch (attributeName) {
-      case 'POSITION':
-        name = 'positions';
-        break;
-      case 'NORMAL':
-        name = 'normals';
-        break;
-      case 'TEXCOORD_0':
-        name = 'texCoords';
-        break;
-      case 'COLOR_0':
-        name = 'colors';
-        break;
+    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) });
     }
-    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
-  };
+    const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices);
+    return { attributes, bufferLayout, vertexCount };
 }
-//# sourceMappingURL=gpu-geometry.js.map

package/dist/geometry/gpu-table.js

@@ -1,2 +1,42 @@
+"use strict";
+/*
+export function getAttributeLayoutsFromGeometry(geometry: Geometry) {
+  const layouts: Record<string, {}> = {};
+  let indices = geometry.indices;
 
-//# sourceMappingURL=gpu-table.js.map
+  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();
+}
+*/