@luma.gl/engine 8.6.0-alpha.5 → 9.0.0-alpha.10

package/src/lib/animation-props.ts

@@ -0,0 +1,31 @@
+import {Device} from '@luma.gl/api';
+import {Timeline} from '../animation/timeline'
+import type {AnimationLoop} from './animation-loop';
+
+/** Properties passed to every render frame  */
+export type AnimationProps = {
+  device: Device;
+  animationLoop: AnimationLoop;
+
+  /** @todo Should be canvasContext */
+  canvas: HTMLCanvasElement | OffscreenCanvas;
+  useDevicePixels: number | boolean;
+  width: number;
+  height: number;
+  aspect: number;
+
+  // Animation props
+  time: number;
+  startTime: number;
+  engineTime: number;
+  tick: number;
+  tock: number;
+
+  // Initial values
+  needsRedraw?: string | false;
+
+  timeline: Timeline | null;
+
+  // Experimental
+  _mousePosition?: [number, number] | null; // [offsetX, offsetY],
+};

package/src/{utils → lib}/clip-space.ts

@@ -1,6 +1,8 @@
+
 // ClipSpace
+/*
 import GL from '@luma.gl/constants';
-import Model, {ModelProps} from '../lib/model';
+import Model, {ModelProps} from './model';
 import Geometry from '../geometry/geometry';
 
 const CLIPSPACE_VERTEX_SHADER = `\
@@ -20,7 +22,7 @@ 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];
 
 
@@ -46,3 +48,4 @@ export default class ClipSpace extends Model {
     this.setVertexCount(4);
   }
 }
+*/

package/src/lib/model-utils.ts

@@ -1,5 +1,5 @@
-import GL from '@luma.gl/constants';
-import {Buffer, assert} from '@luma.gl/webgl';
+import {Device, Buffer, assert} from '@luma.gl/api';
+import type Geometry from '../geometry/geometry';
 
 // Support for mapping new geometries with glTF attribute names to "classic" luma.gl shader names
 const GLTF_TO_LUMA_ATTRIBUTE_MAP = {
@@ -11,56 +11,83 @@ const GLTF_TO_LUMA_ATTRIBUTE_MAP = {
   TEXCOORD_2: 'texCoords2'
 };
 
-export function getBuffersFromGeometry(gl: WebGLRenderingContext, geometry, options?) {
-  const buffers: Record<string, Buffer | [Buffer, {}]> = {};
+/*
+export function getAttributeLayoutsFromGeometry(geometry: Geometry) {
+  const layouts: Record<string, {}> = {};
   let indices = geometry.indices;
 
-  for (const name in geometry.attributes) {
-    const attribute = geometry.attributes[name];
-    const remappedName = mapAttributeName(name, options);
+  for (const [name, attribute] of Object.entries(geometry.attributes)) {
+    const remappedName = mapAttributeName(name);
 
-    if (name === 'indices') {
-      indices = attribute;
-    } else if (attribute.constant) {
-      buffers[remappedName] = attribute.value;
+    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] = [new Buffer(gl, typedArray), accessor];
+      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();
+}
+*/
 
-  if (indices) {
-    const data = indices.value || indices;
-    assert(
-      data instanceof Uint16Array || data instanceof Uint32Array,
-      'attribute array for "indices" must be of integer type'
-    );
-    const accessor = {
-      size: 1,
-      isIndexed: indices.isIndexed === undefined ? true : indices.isIndexed
-    };
-    buffers.indices = [
-      new Buffer(gl, {
-        data,
-        target: GL.ELEMENT_ARRAY_BUFFER
-      }),
-      accessor
-    ];
+export function getIndexBufferFromGeometry(device: Device, geometry: Geometry): Buffer | undefined {
+  if (!geometry.indices) {
+    return undefined;
+  }
+
+  // @ts-expect-error
+  const data = geometry.indices.value || geometry.indices;
+  assert(
+    data instanceof Uint16Array || data instanceof Uint32Array,
+    'attribute array for "indices" must be of integer type'
+  );
+  return device.createBuffer({usage: Buffer.INDEX, data});
+}
+
+export function getAttributeBuffersFromGeometry(device: Device, geometry: Geometry): Record<string, Buffer> {
+  const buffers: Record<string, Buffer> = {};
+
+  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;
+      buffers[remappedName] = device.createBuffer({data: typedArray, id: `${remappedName}-buffer`});
+    }
   }
 
   return buffers;
 }
 
-function mapAttributeName(name, options) {
-  const {attributeMap = GLTF_TO_LUMA_ATTRIBUTE_MAP} = options || {};
-  return (attributeMap && attributeMap[name]) || name;
+function mapAttributeName(name: string): string {
+  return GLTF_TO_LUMA_ATTRIBUTE_MAP[name] || name;
 }
 
+/*
 // Check for well known attribute names
 // eslint-disable-next-line complexity
 export function inferAttributeAccessor(attributeName, attribute) {
@@ -94,3 +121,4 @@ export function inferAttributeAccessor(attributeName, attribute) {
 
   assert(Number.isFinite(attribute.size), `attribute ${attributeName} needs size`);
 }
+*/