@luma.gl/engine 9.0.0-alpha.32 → 9.0.0-alpha.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/engine",
-  "version": "9.0.0-alpha.32",
+  "version": "9.0.0-alpha.33",
   "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/constants": "9.0.0-alpha.32",
-    "@luma.gl/core": "9.0.0-alpha.32",
-    "@luma.gl/shadertools": "9.0.0-alpha.32",
-    "@luma.gl/webgl": "9.0.0-alpha.32",
+    "@luma.gl/constants": "9.0.0-alpha.33",
+    "@luma.gl/core": "9.0.0-alpha.33",
+    "@luma.gl/shadertools": "9.0.0-alpha.33",
+    "@luma.gl/webgl": "9.0.0-alpha.33",
     "@math.gl/core": "4.0.0-alpha.4",
     "@probe.gl/log": "^4.0.2",
     "@probe.gl/stats": "^4.0.2"
   },
-  "gitHead": "08b30dcae4aee321738cf05b509cef6b3b24c880"
+  "gitHead": "65a38ac7ed371767303b5ded6cc3d34373e904e3"
 }

package/src/geometry/geometry.ts

@@ -24,7 +24,7 @@ export type GeometryAttributes = {
   NORMAL: GeometryAttribute;
   TEXCOORD_0: GeometryAttribute;
   COLOR_0?: GeometryAttribute;
-  indices?: {size?: number; value: Uint32Array | Uint16Array};
+  indices?: GeometryAttribute & {size: 1; value: Uint32Array | Uint16Array};
 };
 
 export type GeometryAttribute = {
@@ -38,7 +38,7 @@ export class Geometry {
   /** Determines how vertices are read from the 'vertex' attributes */
   readonly topology?: PrimitiveTopology;
   readonly vertexCount: number;
-  readonly indices?: Uint16Array | Uint32Array;
+  readonly indices?: GeometryAttribute;
   readonly attributes: {
     POSITION: GeometryAttribute;
     NORMAL: GeometryAttribute;
@@ -56,7 +56,6 @@ export class Geometry {
     this.topology = props.topology;
 
     if (indices) {
-      // @ts-expect-error
       this.indices = ArrayBuffer.isView(indices) ? {value: indices, size: 1} : indices;
     }
 
@@ -81,17 +80,14 @@ export class Geometry {
       // Move indices to separate field
       if (attributeName === 'indices') {
         assert(!this.indices);
-        // @ts-expect-error
         this.indices = attribute;
       } else {
         this.attributes[attributeName] = attribute;
       }
     }
 
-    // @ts-expect-error
     if (this.indices && this.indices.isIndexed !== undefined) {
       this.indices = Object.assign({}, this.indices);
-      // @ts-expect-error
       delete this.indices.isIndexed;
     }
 
@@ -102,9 +98,11 @@ export class Geometry {
     return this.vertexCount;
   }
 
-  // Return an object with all attributes plus indices added as a field.
+  /** 
+   * Return an object with all attributes plus indices added as a field.
+   * TODO Geometry types are a mess
+   */
   getAttributes(): GeometryAttributes {
-    // @ts-expect-error Geometry types are a mess
     return this.indices ? {indices: this.indices, ...this.attributes} : this.attributes;
   }
 
@@ -114,22 +112,27 @@ export 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)
+  /**
+   * 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: any, indices: any): 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);

package/src/geometry/gpu-geometry.ts

@@ -14,16 +14,16 @@ export type GPUGeometryProps = {
     | 'triangle-strip'
     | 'triangle-fan-webgl';
   /** Auto calculated from attributes if not provided */
-  vertexCount?: number;
-  bufferLayout?: BufferLayout[];
+  vertexCount: number;
+  bufferLayout: BufferLayout[];
   indices?: Buffer | null;
   attributes: GPUGeometryAttributes;
 };
 
 export type GPUGeometryAttributes = {
   positions: Buffer;
-  normals: Buffer;
-  texCoords: Buffer;
+  normals?: Buffer;
+  texCoords?: Buffer;
   colors?: Buffer;
 };
 
@@ -39,8 +39,8 @@ export class GPUGeometry {
   readonly indices?: Buffer | null;
   readonly attributes: {
     positions: Buffer;
-    normals: Buffer;
-    texCoords: Buffer;
+    normals?: Buffer;
+    texCoords?: Buffer;
     colors?: Buffer;
   };
 
@@ -50,21 +50,21 @@ export class GPUGeometry {
     this.indices = props.indices || null;
     this.attributes = props.attributes;
 
-    // 
-    this.vertexCount = props.vertexCount || this._calculateVertexCount(this.attributes.positions);
+    //
+    this.vertexCount = props.vertexCount;
 
     // Populate default bufferLayout
     this.bufferLayout = props.bufferLayout || [];
     if (!this.bufferLayout.find(layout => layout.name === 'positions')) {
       this.bufferLayout.push({name: 'positions', format: 'float32x3'});
     }
-    if (!this.bufferLayout.find(layout => layout.name === 'normals')) {
+    if (this.attributes.normals && !this.bufferLayout.find(layout => layout.name === 'normals')) {
       this.bufferLayout.push({name: 'normals', format: 'float32x3'});
     }
-    if (!this.bufferLayout.find(layout => layout.name === 'texCoords')) {
+    if (this.attributes.texCoords && !this.bufferLayout.find(layout => layout.name === 'texCoords')) {
       this.bufferLayout.push({name: 'texCoords', format: 'float32x2'});
     }
-    if (!this.bufferLayout.find(layout => layout.name === 'colors')) {
+    if (this.attributes.colors && !this.bufferLayout.find(layout => layout.name === 'colors')) {
       this.bufferLayout.push({name: 'colors', format: 'float32x3'});
     }
 
@@ -106,11 +106,12 @@ export function makeGPUGeometry(device: Device, geometry: Geometry | GPUGeometry
   }
 
   const indices = getIndexBufferFromGeometry(device, geometry);
-  const attributes = getAttributeBuffersFromGeometry(device, geometry);
+  const {attributes, bufferLayout} = getAttributeBuffersFromGeometry(device, geometry);
   return new GPUGeometry({
-    topology: geometry.topology, 
-    vertexCount: geometry.vertexCount, 
-    indices, 
+    topology: geometry.topology || 'triangle-list',
+    bufferLayout,
+    vertexCount: geometry.vertexCount,
+    indices,
     attributes
   });
 }
@@ -120,8 +121,7 @@ export function getIndexBufferFromGeometry(device: Device, geometry: Geometry):
     return undefined;
   }
 
-  // @ts-expect-error
-  const data = geometry.indices.value || geometry.indices;
+  const data = geometry.indices.value;
   assert(
     data instanceof Uint16Array || data instanceof Uint32Array,
     'attribute array for "indices" must be of integer type'
@@ -129,31 +129,30 @@ export function getIndexBufferFromGeometry(device: Device, geometry: Geometry):
   return device.createBuffer({usage: Buffer.INDEX, data});
 }
 
-export function getAttributeBuffersFromGeometry(device: Device, geometry: Geometry): GPUGeometryAttributes {
+export function getAttributeBuffersFromGeometry(
+  device: Device,
+  geometry: Geometry
+): {attributes: GPUGeometryAttributes, bufferLayout: BufferLayout[], vertexCount: number} {
   const positions = geometry.attributes.positions || geometry.attributes.POSITION;
   const normals = geometry.attributes.normals || geometry.attributes.NORMAL;
   const texCoords = geometry.attributes.texCoords || geometry.attributes.TEXCOORD_0;
 
-  const buffers: GPUGeometryAttributes = {
-    positions: device.createBuffer({data: positions.value, id: 'positions-buffer'}),
-    normals: device.createBuffer({data: normals.value, id: 'normals-buffer'}),
-    texCoords: device.createBuffer({data: texCoords.value, id: 'texCoords-buffer'})
+  const attributes: GPUGeometryAttributes = {
+    positions: device.createBuffer({data: positions.value, id: 'positions-buffer'})
   };
+  const bufferLayout: BufferLayout[] = [
+    {name: 'positions', format: `float32x${positions.size as 2 | 3 | 4}`}
+  ];
+  if (normals) {
+    attributes.normals = device.createBuffer({data: normals.value, id: 'normals-buffer'});
+    bufferLayout.push({name: 'normals', format: `float32x${normals.size as 2 | 3 | 4}`});
+  }
+  if (texCoords) {
+    attributes.texCoords = device.createBuffer({data: texCoords.value, id: 'texCoords-buffer'});
+    bufferLayout.push({name: 'texCoords', format: `float32x${texCoords.size as 2 | 3 | 4}`});
+  }
 
-  return buffers;
-}
-
-// Support for mapping new geometries with glTF attribute names to "classic" luma.gl shader names
-const GLTF_TO_LUMA_ATTRIBUTE_MAP = {
-  POSITION: 'positions',
-  NORMAL: 'normals',
-  COLOR_0: 'colors',
-  TEXCOORD_0: 'texCoords',
-  TEXCOORD_1: 'texCoords1',
-  TEXCOORD_2: 'texCoords2'
-};
+  const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices)
 
-export function mapAttributeName(name: string): string {
-  // @ts-ignore-error
-  return GLTF_TO_LUMA_ATTRIBUTE_MAP[name] || name;
+  return {attributes, bufferLayout, vertexCount};
 }

package/src/model/model.ts

@@ -3,12 +3,11 @@
 import type {TypedArray, RenderPipelineProps, RenderPipelineParameters, BufferLayout} from '@luma.gl/core';
 import type {Binding, UniformValue, PrimitiveTopology} from '@luma.gl/core';
 import {Device, Buffer, RenderPipeline, RenderPass, log, uid, deepEqual} from '@luma.gl/core';
-import type {ShaderModule} from '@luma.gl/shadertools';
+import type {ShaderModule, PlatformInfo} from '@luma.gl/shadertools';
 import {ShaderAssembler} from '@luma.gl/shadertools';
 import type {Geometry} from '../geometry/geometry';
 import {GPUGeometry, makeGPUGeometry} from '../geometry/gpu-geometry';
 import {PipelineFactory} from '../lib/pipeline-factory';
-import {buildShaders} from './model-shaders';
 
 export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs'> & {
   // Model also accepts a string shaders
@@ -112,7 +111,15 @@ export class Model {
 
     Object.assign(this.userData, props.userData);
 
-    const {vs, fs, getUniforms} = buildShaders(device, this.props);
+    /** Create a shadertools platform info from the Device */
+    const platformInfo: PlatformInfo = {
+      type: device.info.type,
+      shaderLanguage: device.info.shadingLanguages[0],
+      gpu: device.info.gpu,
+      features: device.features
+    };
+
+    const {vs, fs, getUniforms} = this.props.shaderAssembler.assembleShaders(platformInfo, this.props);
     this.vs = vs;
     this.fs = fs;
     this._getModuleUniforms = getUniforms;
@@ -125,9 +132,8 @@ export class Model {
     this.parameters = this.props.parameters;
 
     // Geometry, if provided, sets several attributes, indices, and also vertex count and topology
-    const gpuGeometry = props.geometry && makeGPUGeometry(device, props.geometry);
-    if (gpuGeometry) {
-      this.setGeometry(gpuGeometry);
+    if (props.geometry) {
+      this.setGeometry(props.geometry);
     }
 
     this.pipelineFactory =
@@ -198,16 +204,18 @@ export class Model {
 
   /** 
    * Updates the optional geometry
+  * Geometry, sets several attributes, indices, and also vertex count and topology
    * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU
    */
-  setGeometry(geometry: GPUGeometry): void {
-    this.setTopology(geometry.topology || 'triangle-list');
-    this.bufferLayout = mergeBufferLayouts(this.bufferLayout, geometry.bufferLayout);
+  setGeometry(geometry: GPUGeometry | Geometry): void {
+    const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry);
+    this.setTopology(gpuGeometry.topology || 'triangle-list');
+    this.bufferLayout = mergeBufferLayouts(this.bufferLayout, gpuGeometry.bufferLayout);
 
     // TODO - delete previous geometry?
-    this.vertexCount = geometry.vertexCount;
-    this.setAttributes(geometry.attributes);
-    this.setIndexBuffer(geometry.indices);
+    this.vertexCount = gpuGeometry.vertexCount;
+    this.setAttributes(gpuGeometry.attributes);
+    this.setIndexBuffer(gpuGeometry.indices);
   }
 
   /** 

package/dist/model/model-shaders.d.ts

@@ -1,35 +0,0 @@
-import type { Device } from '@luma.gl/core';
-import type { ShaderModule, HookFunction } from '@luma.gl/shadertools';
-import { ShaderAssembler } from '@luma.gl/shadertools';
-export type ModelShaderProps = {
-    vs?: {
-        glsl?: string;
-        wgsl?: string;
-    } | string | null;
-    fs?: {
-        glsl?: string;
-        wgsl?: string;
-    } | string | null;
-    /** shadertool shader modules (added to shader code) */
-    modules?: ShaderModule[];
-    /** Shadertool module defines (configures shader code)*/
-    defines?: Record<string, string | number | boolean>;
-    inject?: Record<string, string>;
-    hooks?: Record<string, HookFunction>;
-    transpileToGLSL100?: boolean;
-    shaderAssembler: ShaderAssembler;
-};
-type GetUniformsFunc = (props?: Record<string, any>) => Record<string, any>;
-/**
- * TODO - should this functionality move into shadertools / assembleShaders ?
- * @param device
- * @param props
- * @returns
- */
-export declare function buildShaders(device: Device, props: ModelShaderProps): {
-    vs: string;
-    fs: string | undefined;
-    getUniforms: GetUniformsFunc;
-};
-export {};
-//# sourceMappingURL=model-shaders.d.ts.map

package/dist/model/model-shaders.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"model-shaders.d.ts","sourceRoot":"","sources":["../../src/model/model-shaders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAC,YAAY,EAAE,YAAY,EAAC,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAErD,MAAM,MAAM,gBAAgB,GAAG;IAE7B,EAAE,CAAC,EAAE;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,GAAG,MAAM,GAAG,IAAI,CAAC;IACpD,EAAE,CAAC,EAAE;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,GAAG,MAAM,GAAG,IAAI,CAAC;IACpD,uDAAuD;IACvD,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACrC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B,eAAe,EAAE,eAAe,CAAC;CAClC,CAAC;AAEF,KAAK,eAAe,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAE5E;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,gBAAgB,GACtB;IACD,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;IACvB,WAAW,EAAE,eAAe,CAAA;CAC7B,CAmBA"}

package/dist/model/model-shaders.js

@@ -1,38 +0,0 @@
-export function buildShaders(device, props) {
-  if (!props.vs) {
-    throw new Error('no vertex shader');
-  }
-  const vs = getShaderSource(device, props.vs);
-  let fs;
-  if (props.fs) {
-    fs = getShaderSource(device, props.fs);
-  }
-  const platformInfo = {
-    type: device.info.type,
-    gpu: device.info.gpu,
-    features: device.features
-  };
-  return props.shaderAssembler.assembleShaders(platformInfo, {
-    ...props,
-    fs,
-    vs
-  });
-}
-function getShaderSource(device, shader) {
-  if (typeof shader === 'string') {
-    return shader;
-  }
-  switch (device.info.type) {
-    case 'webgpu':
-      if (shader !== null && shader !== void 0 && shader.wgsl) {
-        return shader.wgsl;
-      }
-      throw new Error('WebGPU does not support GLSL shaders');
-    default:
-      if (shader !== null && shader !== void 0 && shader.glsl) {
-        return shader.glsl;
-      }
-      throw new Error('WebGL does not support WGSL shaders');
-  }
-}
-//# sourceMappingURL=model-shaders.js.map

package/dist/model/model-shaders.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"model-shaders.js","names":["buildShaders","device","props","vs","Error","getShaderSource","fs","platformInfo","type","info","gpu","features","shaderAssembler","assembleShaders","shader","wgsl","glsl"],"sources":["../../src/model/model-shaders.ts"],"sourcesContent":["import type {Device} from '@luma.gl/core';\nimport type {ShaderModule, HookFunction} from '@luma.gl/shadertools';\nimport {ShaderAssembler} from '@luma.gl/shadertools';\n\nexport type ModelShaderProps = {\n  // Model also accepts a string shaders\n  vs?: {glsl?: string; wgsl?: string} | string | null;\n  fs?: {glsl?: string; wgsl?: string} | string | null;\n  /** shadertool shader modules (added to shader code) */\n  modules?: ShaderModule[];\n  /** Shadertool module defines (configures shader code)*/\n  defines?: Record<string, string | number | boolean>;\n  inject?: Record<string, string>;\n  hooks?: Record<string, HookFunction>;\n  transpileToGLSL100?: boolean;\n\n  shaderAssembler: ShaderAssembler;\n};\n\ntype GetUniformsFunc = (props?: Record<string, any>) => Record<string, any>;\n\n/**\n * TODO - should this functionality move into shadertools / assembleShaders ?\n * @param device\n * @param props\n * @returns\n */\nexport function buildShaders(\n  device: Device,\n  props: ModelShaderProps\n): {\n  vs: string; \n  fs: string | undefined; \n  getUniforms: GetUniformsFunc\n} {\n  if (!props.vs) {\n    throw new Error('no vertex shader');\n  }\n\n  // Resolve WGSL vs GLSL\n  const vs = getShaderSource(device, props.vs);\n  let fs;\n  if (props.fs) {\n    fs = getShaderSource(device, props.fs);\n  }\n\n  const platformInfo = {\n    type: device.info.type,\n    gpu: device.info.gpu,\n    features: device.features\n  };\n\n  return props.shaderAssembler.assembleShaders(platformInfo, {...props, fs, vs});\n}\n\n/** Create a shader from the different overloads */\nfunction getShaderSource(device: Device, shader: string | {glsl?: string; wgsl?: string}): string {\n  // TODO - detect WGSL/GLSL and throw an error if not supported\n  if (typeof shader === 'string') {\n    return shader;\n  }\n\n  switch (device.info.type) {\n    case 'webgpu':\n      if (shader?.wgsl) {\n        return shader.wgsl;\n      }\n      throw new Error('WebGPU does not support GLSL shaders');\n\n    default:\n      if (shader?.glsl) {\n        return shader.glsl;\n      }\n      throw new Error('WebGL does not support WGSL shaders');\n  }\n}\n"],"mappings":"AA2BA,OAAO,SAASA,YAAYA,CAC1BC,MAAc,EACdC,KAAuB,EAKvB;EACA,IAAI,CAACA,KAAK,CAACC,EAAE,EAAE;IACb,MAAM,IAAIC,KAAK,CAAC,kBAAkB,CAAC;EACrC;EAGA,MAAMD,EAAE,GAAGE,eAAe,CAACJ,MAAM,EAAEC,KAAK,CAACC,EAAE,CAAC;EAC5C,IAAIG,EAAE;EACN,IAAIJ,KAAK,CAACI,EAAE,EAAE;IACZA,EAAE,GAAGD,eAAe,CAACJ,MAAM,EAAEC,KAAK,CAACI,EAAE,CAAC;EACxC;EAEA,MAAMC,YAAY,GAAG;IACnBC,IAAI,EAAEP,MAAM,CAACQ,IAAI,CAACD,IAAI;IACtBE,GAAG,EAAET,MAAM,CAACQ,IAAI,CAACC,GAAG;IACpBC,QAAQ,EAAEV,MAAM,CAACU;EACnB,CAAC;EAED,OAAOT,KAAK,CAACU,eAAe,CAACC,eAAe,CAACN,YAAY,EAAE;IAAC,GAAGL,KAAK;IAAEI,EAAE;IAAEH;EAAE,CAAC,CAAC;AAChF;AAGA,SAASE,eAAeA,CAACJ,MAAc,EAAEa,MAA+C,EAAU;EAEhG,IAAI,OAAOA,MAAM,KAAK,QAAQ,EAAE;IAC9B,OAAOA,MAAM;EACf;EAEA,QAAQb,MAAM,CAACQ,IAAI,CAACD,IAAI;IACtB,KAAK,QAAQ;MACX,IAAIM,MAAM,aAANA,MAAM,eAANA,MAAM,CAAEC,IAAI,EAAE;QAChB,OAAOD,MAAM,CAACC,IAAI;MACpB;MACA,MAAM,IAAIX,KAAK,CAAC,sCAAsC,CAAC;IAEzD;MACE,IAAIU,MAAM,aAANA,MAAM,eAANA,MAAM,CAAEE,IAAI,EAAE;QAChB,OAAOF,MAAM,CAACE,IAAI;MACpB;MACA,MAAM,IAAIZ,KAAK,CAAC,qCAAqC,CAAC;EAC1D;AACF"}

package/dist/model/model-utils.d.ts

@@ -1,5 +0,0 @@
-import { Device, Buffer } from '@luma.gl/core';
-import type { Geometry } from '../geometry/geometry';
-export declare function getIndexBufferFromGeometry(device: Device, geometry: Geometry): Buffer | null;
-export declare function getAttributeBuffersFromGeometry(device: Device, geometry: Geometry): Record<string, Buffer>;
-//# sourceMappingURL=model-utils.d.ts.map

package/dist/model/model-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"model-utils.d.ts","sourceRoot":"","sources":["../../src/model/model-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAE,MAAM,EAAS,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAsDnD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI,CAY5F;AAED,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAc1G"}

package/dist/model/model-utils.js

@@ -1,40 +0,0 @@
-import { Buffer, assert } from '@luma.gl/core';
-const GLTF_TO_LUMA_ATTRIBUTE_MAP = {
-  POSITION: 'positions',
-  NORMAL: 'normals',
-  COLOR_0: 'colors',
-  TEXCOORD_0: 'texCoords',
-  TEXCOORD_1: 'texCoords1',
-  TEXCOORD_2: 'texCoords2'
-};
-export function getIndexBufferFromGeometry(device, geometry) {
-  if (!geometry.indices) {
-    return null;
-  }
-  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, geometry) {
-  const buffers = {};
-  for (const [name, attribute] of Object.entries(geometry.attributes)) {
-    const remappedName = mapAttributeName(name);
-    if (attribute !== null && attribute !== void 0 && attribute.constant) {
-      throw new Error('constant attributes not supported');
-    } else {
-      const typedArray = attribute === null || attribute === void 0 ? void 0 : attribute.value;
-      buffers[remappedName] = device.createBuffer({
-        data: typedArray,
-        id: "".concat(remappedName, "-buffer")
-      });
-    }
-  }
-  return buffers;
-}
-function mapAttributeName(name) {
-  return GLTF_TO_LUMA_ATTRIBUTE_MAP[name] || name;
-}
-//# sourceMappingURL=model-utils.js.map

package/dist/model/model-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"model-utils.js","names":["Buffer","assert","GLTF_TO_LUMA_ATTRIBUTE_MAP","POSITION","NORMAL","COLOR_0","TEXCOORD_0","TEXCOORD_1","TEXCOORD_2","getIndexBufferFromGeometry","device","geometry","indices","data","value","Uint16Array","Uint32Array","createBuffer","usage","INDEX","getAttributeBuffersFromGeometry","buffers","name","attribute","Object","entries","attributes","remappedName","mapAttributeName","constant","Error","typedArray","id","concat"],"sources":["../../src/model/model-utils.ts"],"sourcesContent":["import {Device, Buffer, assert} from '@luma.gl/core';\nimport type {Geometry} from '../geometry/geometry';\n\n// Support for mapping new geometries with glTF attribute names to \"classic\" luma.gl shader names\nconst GLTF_TO_LUMA_ATTRIBUTE_MAP = {\n  POSITION: 'positions',\n  NORMAL: 'normals',\n  COLOR_0: 'colors',\n  TEXCOORD_0: 'texCoords',\n  TEXCOORD_1: 'texCoords1',\n  TEXCOORD_2: 'texCoords2'\n};\n\n/*\nexport function getAttributeLayoutsFromGeometry(geometry: Geometry) {\n  const layouts: Record<string, {}> = {};\n  let indices = geometry.indices;\n\n  for (const [name, attribute] of Object.entries(geometry.attributes)) {\n    const remappedName = mapAttributeName(name);\n\n    if (attribute.constant) {\n      throw new Error('constant attributes not supported');\n    } else {\n      const typedArray = attribute.value;\n      // Create accessor by copying the attribute and removing `value``\n      const accessor = {...attribute};\n      delete accessor.value;\n      buffers[remappedName] = [device.createBuffer(typedArray), accessor];\n\n      inferAttributeAccessor(name, accessor);\n    }\n  }\n}\n\nexport class Table {\n  length: number;\n  // columns: Record<string, TypedArray> = {};\n}\n\nexport class GPUTable {\n  length: number;\n  columns: Record<string, Buffer> = {};\n}\n\nexport function convertTableToGPUTable(table: Table) {\n  // for (const ) {}\n}\n\nexport function renameTableColumns(table: Table, map: (name: string) => string) {\n  const newColumns = table.columns.reduce()\n  table.clone();\n}\n*/\n\nexport function getIndexBufferFromGeometry(device: Device, geometry: Geometry): Buffer | null {\n  if (!geometry.indices) {\n    return null;\n  }\n\n  // @ts-expect-error\n  const data = geometry.indices.value || geometry.indices;\n  assert(\n    data instanceof Uint16Array || data instanceof Uint32Array,\n    'attribute array for \"indices\" must be of integer type'\n  );\n  return device.createBuffer({usage: Buffer.INDEX, data});\n}\n\nexport function getAttributeBuffersFromGeometry(device: Device, geometry: Geometry): Record<string, Buffer> {\n  const buffers: Record<string, Buffer> = {};\n\n  for (const [name, attribute] of Object.entries(geometry.attributes)) {\n    const remappedName = mapAttributeName(name);\n    if (attribute?.constant) {\n      throw new Error('constant attributes not supported');\n    } else {\n      const typedArray = attribute?.value;\n      buffers[remappedName] = device.createBuffer({data: typedArray, id: `${remappedName}-buffer`});\n    }\n  }\n\n  return buffers;\n}\n\nfunction mapAttributeName(name: string): string {\n  // @ts-ignore-error\n  return GLTF_TO_LUMA_ATTRIBUTE_MAP[name] || name;\n}\n\n/*\n// Check for well known attribute names\n// eslint-disable-next-line complexity\nexport function inferAttributeAccessor(attributeName, attribute) {\n  let category;\n  switch (attributeName) {\n    case 'texCoords':\n    case 'texCoord1':\n    case 'texCoord2':\n    case 'texCoord3':\n      category = 'uvs';\n      break;\n    case 'vertices':\n    case 'positions':\n    case 'normals':\n    case 'pickingColors':\n      category = 'vectors';\n      break;\n    default:\n  }\n\n  // Check for categorys\n  switch (category) {\n    case 'vectors':\n      attribute.size = attribute.size || 3;\n      break;\n    case 'uvs':\n      attribute.size = attribute.size || 2;\n      break;\n    default:\n  }\n\n  assert(Number.isFinite(attribute.size), `attribute ${attributeName} needs size`);\n}\n*/\n"],"mappings":"AAAA,SAAgBA,MAAM,EAAEC,MAAM,QAAO,eAAe;AAIpD,MAAMC,0BAA0B,GAAG;EACjCC,QAAQ,EAAE,WAAW;EACrBC,MAAM,EAAE,SAAS;EACjBC,OAAO,EAAE,QAAQ;EACjBC,UAAU,EAAE,WAAW;EACvBC,UAAU,EAAE,YAAY;EACxBC,UAAU,EAAE;AACd,CAAC;AA4CD,OAAO,SAASC,0BAA0BA,CAACC,MAAc,EAAEC,QAAkB,EAAiB;EAC5F,IAAI,CAACA,QAAQ,CAACC,OAAO,EAAE;IACrB,OAAO,IAAI;EACb;EAGA,MAAMC,IAAI,GAAGF,QAAQ,CAACC,OAAO,CAACE,KAAK,IAAIH,QAAQ,CAACC,OAAO;EACvDX,MAAM,CACJY,IAAI,YAAYE,WAAW,IAAIF,IAAI,YAAYG,WAAW,EAC1D,uDACF,CAAC;EACD,OAAON,MAAM,CAACO,YAAY,CAAC;IAACC,KAAK,EAAElB,MAAM,CAACmB,KAAK;IAAEN;EAAI,CAAC,CAAC;AACzD;AAEA,OAAO,SAASO,+BAA+BA,CAACV,MAAc,EAAEC,QAAkB,EAA0B;EAC1G,MAAMU,OAA+B,GAAG,CAAC,CAAC;EAE1C,KAAK,MAAM,CAACC,IAAI,EAAEC,SAAS,CAAC,IAAIC,MAAM,CAACC,OAAO,CAACd,QAAQ,CAACe,UAAU,CAAC,EAAE;IACnE,MAAMC,YAAY,GAAGC,gBAAgB,CAACN,IAAI,CAAC;IAC3C,IAAIC,SAAS,aAATA,SAAS,eAATA,SAAS,CAAEM,QAAQ,EAAE;MACvB,MAAM,IAAIC,KAAK,CAAC,mCAAmC,CAAC;IACtD,CAAC,MAAM;MACL,MAAMC,UAAU,GAAGR,SAAS,aAATA,SAAS,uBAATA,SAAS,CAAET,KAAK;MACnCO,OAAO,CAACM,YAAY,CAAC,GAAGjB,MAAM,CAACO,YAAY,CAAC;QAACJ,IAAI,EAAEkB,UAAU;QAAEC,EAAE,KAAAC,MAAA,CAAKN,YAAY;MAAS,CAAC,CAAC;IAC/F;EACF;EAEA,OAAON,OAAO;AAChB;AAEA,SAASO,gBAAgBA,CAACN,IAAY,EAAU;EAE9C,OAAOpB,0BAA0B,CAACoB,IAAI,CAAC,IAAIA,IAAI;AACjD"}

package/src/model/model-shaders.ts

@@ -1,76 +0,0 @@
-import type {Device} from '@luma.gl/core';
-import type {ShaderModule, HookFunction} from '@luma.gl/shadertools';
-import {ShaderAssembler} from '@luma.gl/shadertools';
-
-export type ModelShaderProps = {
-  // Model also accepts a string shaders
-  vs?: {glsl?: string; wgsl?: string} | string | null;
-  fs?: {glsl?: string; wgsl?: string} | string | null;
-  /** shadertool shader modules (added to shader code) */
-  modules?: ShaderModule[];
-  /** Shadertool module defines (configures shader code)*/
-  defines?: Record<string, string | number | boolean>;
-  inject?: Record<string, string>;
-  hooks?: Record<string, HookFunction>;
-  transpileToGLSL100?: boolean;
-
-  shaderAssembler: ShaderAssembler;
-};
-
-type GetUniformsFunc = (props?: Record<string, any>) => Record<string, any>;
-
-/**
- * TODO - should this functionality move into shadertools / assembleShaders ?
- * @param device
- * @param props
- * @returns
- */
-export function buildShaders(
-  device: Device,
-  props: ModelShaderProps
-): {
-  vs: string; 
-  fs: string | undefined; 
-  getUniforms: GetUniformsFunc
-} {
-  if (!props.vs) {
-    throw new Error('no vertex shader');
-  }
-
-  // Resolve WGSL vs GLSL
-  const vs = getShaderSource(device, props.vs);
-  let fs;
-  if (props.fs) {
-    fs = getShaderSource(device, props.fs);
-  }
-
-  const platformInfo = {
-    type: device.info.type,
-    gpu: device.info.gpu,
-    features: device.features
-  };
-
-  return props.shaderAssembler.assembleShaders(platformInfo, {...props, fs, vs});
-}
-
-/** Create a shader from the different overloads */
-function getShaderSource(device: Device, shader: string | {glsl?: string; wgsl?: string}): string {
-  // TODO - detect WGSL/GLSL and throw an error if not supported
-  if (typeof shader === 'string') {
-    return shader;
-  }
-
-  switch (device.info.type) {
-    case 'webgpu':
-      if (shader?.wgsl) {
-        return shader.wgsl;
-      }
-      throw new Error('WebGPU does not support GLSL shaders');
-
-    default:
-      if (shader?.glsl) {
-        return shader.glsl;
-      }
-      throw new Error('WebGL does not support WGSL shaders');
-  }
-}