@loaders.gl/scene 5.0.0-beta.1 → 5.0.0-beta.10

package/src/materialx/procedural-graph.ts

@@ -0,0 +1,94 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+
+/** Typed connection to one node output. */
+export interface ProceduralConnection {
+  /** Stable identifier of the upstream node. */
+  node: string;
+  /** Name of its output port. */
+  output: string;
+}
+
+/** Input supplied by a constant or another node. */
+export interface ProceduralInput {
+  /** Declared value type. */
+  type: string;
+  /** Constant value, retained without implicit conversion. */
+  value?: unknown;
+  /** Optional upstream connection. */
+  connection?: ProceduralConnection;
+}
+
+/** Renderer-independent operation with explicitly declared ports. */
+export interface ProceduralNode {
+  /** Stable node identifier, unique within the graph. */
+  id: string;
+  /** Operation identifier for a downstream implementation registry. */
+  operation: string;
+  /** Named inputs. */
+  inputs: Record<string, ProceduralInput>;
+  /** Named output value types. */
+  outputs: Record<string, string>;
+}
+
+/** Graph contract independent of GPU resources or shader languages. */
+export interface ProceduralGraph {
+  /** Nodes in authored order. */
+  nodes: ProceduralNode[];
+  /** Named graph outputs and their upstream connections. */
+  outputs: Record<string, ProceduralConnection>;
+}
+
+/**
+ * Validates explicit references and exact port types, returning dependency-first nodes.
+ * Does not infer conversions, resolve MaterialX definitions, or evaluate operations.
+ */
+export function orderProceduralGraph(graph: ProceduralGraph): ProceduralNode[] {
+  const nodes = new Map<string, ProceduralNode>();
+  for (const node of graph.nodes) {
+    if (!node.id || nodes.has(node.id))
+      throw new Error('Procedural graph: duplicate or empty node ID.');
+    nodes.set(node.id, node);
+  }
+  const dependencies = new Map<string, Set<string>>();
+  const dependents = new Map<string, string[]>();
+  for (const node of graph.nodes) {
+    const upstream = new Set<string>();
+    for (const input of Object.values(node.inputs)) {
+      if (!input.connection) continue;
+      if (Object.hasOwn(input, 'value'))
+        throw new Error('Procedural graph: connected input also has a value.');
+      const source = resolveOutput(input.connection);
+      if (source.outputs[input.connection.output] !== input.type) {
+        throw new Error('Procedural graph: incompatible connection types.');
+      }
+      upstream.add(source.id);
+    }
+    dependencies.set(node.id, upstream);
+    for (const identifier of upstream) {
+      const downstream = dependents.get(identifier) || [];
+      downstream.push(node.id);
+      dependents.set(identifier, downstream);
+    }
+  }
+  for (const output of Object.values(graph.outputs)) resolveOutput(output);
+  const ordered = graph.nodes.filter(node => dependencies.get(node.id)!.size === 0);
+  for (let index = 0; index < ordered.length; index++) {
+    for (const identifier of dependents.get(ordered[index].id) || []) {
+      const upstream = dependencies.get(identifier)!;
+      upstream.delete(ordered[index].id);
+      if (!upstream.size) ordered.push(nodes.get(identifier)!);
+    }
+  }
+  if (ordered.length !== graph.nodes.length) throw new Error('Procedural graph: cycle detected.');
+  return ordered;
+
+  /** Resolves an explicitly named output without accepting inherited properties. */
+  function resolveOutput(connection: ProceduralConnection): ProceduralNode {
+    const node = nodes.get(connection.node);
+    if (!node || !Object.hasOwn(node.outputs, connection.output)) {
+      throw new Error('Procedural graph: missing node or output.');
+    }
+    return node;
+  }
+}

package/src/materialx-loader-types.ts

@@ -0,0 +1,24 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+import type {MaterialXDocument} from './materialx/parse-materialx';
+
+/** Loads the parser-bearing MaterialX implementation. */
+async function preload() {
+  const {MaterialXLoaderWithParser} = await import('@loaders.gl/scene/materialx-loader');
+  return MaterialXLoaderWithParser;
+}
+
+/** Metadata-only loader for MaterialX XML documents. */
+export const MaterialXLoader = {
+  name: 'MaterialX',
+  id: 'materialx',
+  module: 'scene',
+  version: 'latest',
+  extensions: ['mtlx'],
+  mimeTypes: ['application/xml'],
+  text: true,
+  dataType: null as unknown as MaterialXDocument,
+  batchType: null as never,
+  options: {},
+  preload
+} as const;

package/src/materialx-loader.ts

@@ -0,0 +1,15 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+import {MaterialXLoader} from './materialx-loader-types';
+import {parseMaterialX} from './materialx/parse-materialx';
+
+const {preload: _preload, ...metadata} = MaterialXLoader;
+
+/** Parser-bearing loader for MaterialX XML, using the native XML parser. */
+export const MaterialXLoaderWithParser = {
+  ...metadata,
+  parse: async (data: ArrayBuffer) => parseMaterialX(new TextDecoder().decode(data)),
+  parseSync: (data: ArrayBuffer) => parseMaterialX(new TextDecoder().decode(data)),
+  parseText: async (text: string) => parseMaterialX(text),
+  parseTextSync: parseMaterialX
+} as const;

package/src/mtl-loader-types.ts

@@ -0,0 +1 @@
+export * from './obj/mtl-loader-types.js';

package/src/mtl-loader.ts

@@ -0,0 +1 @@
+export * from './obj/mtl-loader.js';

package/src/obj/bundled.ts

@@ -4,10 +4,7 @@
 
 export {OBJFormat} from './obj-format';
 export type {OBJLoaderOptions} from './obj-loader-types';
-export {
-  OBJLoaderWithParser as OBJWorkerLoader,
-  OBJLoaderWithParser as OBJLoader
-} from './obj-loader';
+export {OBJLoaderWithParser as OBJLoader} from './obj-loader';
 export {MTLFormat} from './mtl-format';
 export type {MTLLoaderOptions} from './mtl-loader';
 export {

package/src/obj/index.ts

@@ -15,9 +15,3 @@ export {OBJWriter} from './obj-writer';
 export {MTLFormat} from './mtl-format';
 export type {MTLLoaderOptions} from './mtl-loader-types';
 export {MTLLoader} from './mtl-loader-types';
-
-// DEPRECATED EXPORTS
-/** @deprecated Use OBJLoader. */
-export {OBJWorkerLoader} from './obj-loader-types';
-/** @deprecated Use MTLLoader. */
-export {MTLWorkerLoader} from './mtl-loader-types';

package/src/obj/mtl-loader-types.ts

@@ -18,7 +18,7 @@ export type MTLLoaderOptions = LoaderOptions & {
  * Preloads the parser-bearing MTL loader implementation.
  */
 async function preload() {
-  const {MTLLoaderWithParser} = await import('@loaders.gl/scene/obj/mtl-loader');
+  const {MTLLoaderWithParser} = await import('@loaders.gl/scene/mtl-loader');
   return MTLLoaderWithParser;
 }
 
@@ -41,6 +41,3 @@ export const MTLLoader = {
   },
   preload
 } as const satisfies Loader<MTLMaterial[], never, LoaderOptions>;
-
-/** @deprecated Use MTLLoader. */
-export const MTLWorkerLoader = MTLLoader;

package/src/obj/mtl-loader.ts

@@ -5,7 +5,7 @@
 import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/core/loader-utils';
 import type {MTLMaterial, ParseMTLOptions} from './lib/parse-mtl';
 import {parseMTL} from './lib/parse-mtl';
-import {MTLWorkerLoader as MTLWorkerLoaderMetadata} from './mtl-loader-types';
+import {MTLLoader as MTLWorkerLoaderMetadata} from './mtl-loader-types';
 import {MTLLoader as MTLLoaderMetadata} from './mtl-loader-types';
 
 const {preload: _MTLWorkerLoaderPreload, ...MTLWorkerLoaderMetadataWithoutPreload} =

package/src/obj/obj-loader-types.ts

@@ -2,10 +2,11 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import type {Table, RecordBatch} from 'apache-arrow';
 import type {Loader, LoaderOptions} from '@loaders.gl/core/loader-utils';
-import type {Mesh, MeshArrowTable, ArrowTableBatch} from '@loaders.gl/core/schema';
+import type {Mesh} from '@loaders.gl/core/schema';
 import {OBJFormat} from './obj-format';
-import {serializeArrowWorkerTable} from '@loaders.gl/core/schema-utils/arrow-transport';
+import {serializeArrowWorkerTable} from '@loaders.gl/core/arrow-worker-transport';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
@@ -14,7 +15,7 @@ const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
 export type OBJLoaderOptions = LoaderOptions & {
   obj?: {
     /** Output shape. Defaults to a Mesh Arrow table. */
-    shape?: 'mesh' | 'arrow-table';
+    shape?: 'mesh' | 'arrow';
     /** Treat OBJ vertex records as a point cloud and stream `v` rows in batches. */
     pointCloud?: boolean;
     /** Override the URL to the worker bundle (by default loads from unpkg.com) */
@@ -35,13 +36,13 @@ export type OBJMeshBatch = {
 };
 
 /** Public OBJ batch output shapes. */
-export type OBJParsedBatch = OBJMeshBatch | ArrowTableBatch;
+export type OBJParsedBatch = OBJMeshBatch | RecordBatch;
 
 /**
  * Preloads the parser-bearing OBJ loader implementation.
  */
 async function preload() {
-  const {OBJLoaderWithParser} = await import('@loaders.gl/scene/obj/obj-loader');
+  const {OBJLoaderWithParser} = await import('@loaders.gl/scene/obj-loader');
   return OBJLoaderWithParser;
 }
 
@@ -49,9 +50,11 @@ async function preload() {
  * Metadata-only worker loader for the OBJ geometry format
  */
 export const OBJLoader = {
+  defaultShape: 'arrow',
+  supportsNativeArrow: true,
   ...OBJFormat,
 
-  dataType: null as unknown as Mesh | MeshArrowTable,
+  dataType: null as unknown as Mesh | Table,
   batchType: null as unknown as OBJParsedBatch,
   version: VERSION,
   worker: true,
@@ -61,15 +64,12 @@ export const OBJLoader = {
   text: true,
   testText: testOBJFile,
   options: {
-    obj: {shape: 'arrow-table'}
+    obj: {shape: 'arrow'}
   },
   preload
-} as const satisfies Loader<Mesh | MeshArrowTable, OBJParsedBatch, OBJLoaderOptions>;
+} as const satisfies Loader<Mesh | Table, OBJParsedBatch, OBJLoaderOptions>;
 
 function testOBJFile(text: string): boolean {
   // TODO - There could be comment line first
   return text[0] === 'v';
 }
-
-/** @deprecated Use OBJLoader. */
-export const OBJWorkerLoader = OBJLoader;

package/src/obj/obj-loader.ts

@@ -2,7 +2,9 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {OBJLoaderOptions, OBJParsedBatch} from './obj-loader-types';
+import {refineArrowTableBatches, makeArrowMetadataBatch} from '@loaders.gl/core/schema-utils';
+import type {Table} from 'apache-arrow';
+import type {OBJLoaderOptions, OBJMeshBatch, OBJParsedBatch} from './obj-loader-types';
 
 import {
   concatenateArrayBuffersAsync,
@@ -11,13 +13,13 @@ import {
   makeTableScanBatch,
   type LoaderWithParser
 } from '@loaders.gl/core/loader-utils';
-import type {Mesh, MeshArrowTable} from '@loaders.gl/core/schema';
+import type {Mesh, MeshArrowTable, ArrowTableBatch} from '@loaders.gl/core/schema';
 import {
   deserializeArrowWorkerTable,
   serializeArrowWorkerTable
-} from '@loaders.gl/core/schema-utils/arrow-transport';
+} from '@loaders.gl/core/arrow-worker-transport';
 import {
-  convertMeshToTable,
+  convertMeshToArrowTableWrapper,
   convertTableToMesh,
   getMeshBoundingBox
 } from '@loaders.gl/core/schema-utils';
@@ -28,7 +30,7 @@ import {OBJLoader as OBJLoaderMetadata} from './obj-loader-types';
 const {preload: _OBJLoaderPreload, ...OBJLoaderMetadataWithoutPreload} = OBJLoaderMetadata;
 
 function convertOBJMesh(mesh: Mesh, options?: OBJLoaderOptions): Mesh | MeshArrowTable {
-  const table = convertMeshToTable(mesh, 'arrow-table');
+  const table = convertMeshToArrowTableWrapper(mesh);
   return options?.obj?.shape === 'mesh' ? convertTableToMesh(table) : table;
 }
 
@@ -37,44 +39,29 @@ function convertOBJMesh(mesh: Mesh, options?: OBJLoaderOptions): Mesh | MeshArro
 /**
  * Loader for the OBJ geometry format
  */
-export const OBJLoaderWithParser = {
+export const OBJColumnLoader = {
   ...OBJLoaderMetadataWithoutPreload,
+  dataType: null as unknown as Mesh | MeshArrowTable,
+  batchType: null as unknown as OBJMeshBatch | ArrowTableBatch,
   parse: async (arrayBuffer: ArrayBuffer, options?: OBJLoaderOptions) =>
     convertOBJMesh(parseOBJ(new TextDecoder().decode(arrayBuffer), options), options),
   parseTextSync: (text: string, options?: OBJLoaderOptions) =>
     convertOBJMesh(parseOBJ(text, options), options),
-  parseInBatches: async function* (
-    arrayBuffer:
-      | AsyncIterable<ArrayBufferLike | ArrayBufferView>
-      | Iterable<ArrayBufferLike | ArrayBufferView>,
-    options
-  ): AsyncIterable<OBJParsedBatch> {
-    const batchSize = getNumericBatchSize(options);
-    if (options?.obj?.pointCloud) {
-      const textIterator = makeTextDecoderIterator(arrayBuffer as AsyncIterable<ArrayBuffer>);
-      const lineIterator = makeLineIterator(textIterator);
-      yield* parseOBJPointCloudLinesInBatches(lineIterator, options, batchSize);
-      return;
-    }
-
-    const data = await concatenateArrayBuffersAsync(arrayBuffer);
-    const text = new TextDecoder().decode(data);
-    if (hasOBJGeometryRecords(text)) {
-      yield makeOBJBatch(parseOBJ(text, options), options);
-      return;
-    }
-
-    yield* parseOBJPointCloudInBatches(text, options, batchSize);
-  },
+  parseInBatches: (input, options) =>
+    refineArrowTableBatches(parseOBJWithMetadataInBatches(input, options)),
   serializeWorkerResult: serializeArrowWorkerTable,
   deserializeWorkerResult: deserializeOBJWorkerResult,
   serializeWorkerBatch: serializeArrowWorkerTable,
   deserializeWorkerBatch: deserializeOBJWorkerBatch
-} as const satisfies LoaderWithParser<Mesh | MeshArrowTable, OBJParsedBatch, OBJLoaderOptions>;
+} as const satisfies LoaderWithParser<
+  Mesh | MeshArrowTable,
+  OBJMeshBatch | ArrowTableBatch,
+  OBJLoaderOptions
+>;
 
 /** Returns a numeric batch size when batching has an explicit row count. */
 function getNumericBatchSize(options?: OBJLoaderOptions): number | undefined {
-  const batchSize = options?.batchSize ?? options?.core?.batchSize;
+  const batchSize = options?.core?.batchSize;
   return typeof batchSize === 'number' ? batchSize : undefined;
 }
 
@@ -89,7 +76,7 @@ function* parseOBJPointCloudInBatches(
   text: string,
   options?: OBJLoaderOptions,
   batchSize?: number
-): Iterable<OBJParsedBatch> {
+): Iterable<OBJMeshBatch | ArrowTableBatch> {
   const vertexLines = text.split(/\r?\n/).filter(line => line.trimStart().startsWith('v '));
   yield* makeOBJPointCloudBatches(vertexLines, options, batchSize);
 }
@@ -98,7 +85,7 @@ async function* parseOBJPointCloudLinesInBatches(
   lines: AsyncIterable<string>,
   options?: OBJLoaderOptions,
   batchSize?: number
-): AsyncIterable<OBJParsedBatch> {
+): AsyncIterable<OBJMeshBatch | ArrowTableBatch> {
   const normalizedBatchSize = batchSize || 1000;
   let vertexLines: string[] = [];
 
@@ -122,7 +109,7 @@ function* makeOBJPointCloudBatches(
   vertexLines: string[],
   options?: OBJLoaderOptions,
   batchSize?: number
-): Iterable<OBJParsedBatch> {
+): Iterable<OBJMeshBatch | ArrowTableBatch> {
   const normalizedBatchSize = batchSize || vertexLines.length || 1;
 
   for (let rowIndex = 0; rowIndex < vertexLines.length; rowIndex += normalizedBatchSize) {
@@ -170,8 +157,8 @@ function parseOBJPointCloudMesh(vertexLines: string[]): Mesh {
   };
 }
 
-function makeOBJBatch(mesh: Mesh, options?: OBJLoaderOptions): OBJParsedBatch {
-  const table = convertMeshToTable(mesh, 'arrow-table');
+function makeOBJBatch(mesh: Mesh, options?: OBJLoaderOptions): OBJMeshBatch | ArrowTableBatch {
+  const table = convertMeshToArrowTableWrapper(mesh);
   if (options?.obj?.shape === 'mesh') {
     const convertedMesh = convertTableToMesh(table);
     return {
@@ -195,9 +182,72 @@ function deserializeOBJWorkerResult(
 }
 
 /** Restores the OBJ mesh batch envelope after caller-side conversion. */
-function deserializeOBJWorkerBatch(result: unknown, options?: OBJLoaderOptions): OBJParsedBatch {
+function deserializeOBJWorkerBatch(
+  result: unknown,
+  options?: OBJLoaderOptions
+): OBJMeshBatch | ArrowTableBatch {
   const table = deserializeArrowWorkerTable(result);
   if (options?.obj?.shape !== 'mesh') return table;
   const mesh = convertTableToMesh(table);
   return {shape: 'mesh', batchType: 'data', data: mesh, length: table.length};
 }
+
+/** Parses OBJ batches before shared cumulative metadata refinement. */
+async function* parseOBJWithMetadataInBatches(
+  arrayBuffer:
+    | AsyncIterable<ArrayBufferLike | ArrayBufferView>
+    | Iterable<ArrayBufferLike | ArrayBufferView>,
+  options?: OBJLoaderOptions
+): AsyncIterable<OBJMeshBatch | ArrowTableBatch> {
+  const batchSize = getNumericBatchSize(options);
+  if (options?.obj?.pointCloud) {
+    const textIterator = makeTextDecoderIterator(arrayBuffer as AsyncIterable<ArrayBuffer>);
+    const lineIterator = makeLineIterator(textIterator);
+    yield* parseOBJPointCloudLinesInBatches(lineIterator, options, batchSize);
+    return;
+  }
+
+  const data = await concatenateArrayBuffersAsync(arrayBuffer);
+  const text = new TextDecoder().decode(data);
+  if (hasOBJGeometryRecords(text)) {
+    yield makeOBJBatch(parseOBJ(text, options), options);
+    return;
+  }
+
+  yield* parseOBJPointCloudInBatches(text, options, batchSize);
+}
+
+/** Exposes native Arrow output while retaining the worker's column protocol. */
+export const OBJLoaderWithParser = {
+  ...OBJColumnLoader,
+  dataType: OBJLoaderMetadata.dataType,
+  batchType: OBJLoaderMetadata.batchType,
+  parse: async (input: ArrayBuffer, options?: OBJLoaderOptions) =>
+    unwrapOBJTable(await OBJColumnLoader.parse(input, options)),
+  parseTextSync: (input: string, options?: OBJLoaderOptions) =>
+    unwrapOBJTable(OBJColumnLoader.parseTextSync(input, options)),
+  async *parseInBatches(input, options) {
+    for await (const batch of OBJColumnLoader.parseInBatches(input, options)) {
+      if ('shape' in batch && batch.shape === 'arrow-table') {
+        if (batch.data.batches.length) yield* batch.data.batches;
+        else yield makeArrowMetadataBatch(batch.data.schema);
+      } else yield batch;
+    }
+  },
+  deserializeWorkerResult: (result: unknown, options?: OBJLoaderOptions) =>
+    unwrapOBJTable(OBJColumnLoader.deserializeWorkerResult(result, options)),
+  deserializeWorkerBatch(result: unknown, options?: OBJLoaderOptions) {
+    const batch = OBJColumnLoader.deserializeWorkerBatch(result, options);
+    return 'shape' in batch && batch.shape === 'arrow-table'
+      ? (batch.data.batches[0] ?? makeArrowMetadataBatch(batch.data.schema))
+      : batch;
+  }
+} as const satisfies LoaderWithParser<Mesh | Table, OBJParsedBatch, OBJLoaderOptions>;
+
+/** Returns the Arrow table with its file metadata or the requested mesh. */
+function unwrapOBJTable(result: Mesh | MeshArrowTable): Mesh | Table {
+  if ('shape' in result && result.shape === 'arrow-table') {
+    return result.data;
+  }
+  return result as Mesh;
+}

package/src/obj/obj-writer.ts

@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import type {Table} from 'apache-arrow';
 import type {WriterOptions, WriterWithEncoder} from '@loaders.gl/core/loader-utils';
 import type {Mesh, MeshArrowTable, MeshAttribute} from '@loaders.gl/core/schema';
-import {convertMeshToTable, convertTableToMesh} from '@loaders.gl/core/schema-utils';
+import {convertMeshToArrowTableWrapper, convertTableToMesh} from '@loaders.gl/core/schema-utils';
 import {OBJFormat} from './obj-format';
 
 // __VERSION__ is injected by babel-plugin-version-inline
@@ -22,7 +23,7 @@ export type OBJWriterOptions = WriterOptions & {
  */
 export const OBJWriter = {
   ...OBJFormat,
-  dataType: null as unknown as Mesh | MeshArrowTable,
+  dataType: null as unknown as Mesh | MeshArrowTable | Table,
   batchType: null as never,
   version: VERSION,
   options: {
@@ -32,16 +33,19 @@ export const OBJWriter = {
   encode: async (data, options) => encodeOBJSync(data, options),
   encodeSync: encodeOBJSync,
   encodeTextSync: encodeOBJ
-} as const satisfies WriterWithEncoder<Mesh | MeshArrowTable, never, OBJWriterOptions>;
+} as const satisfies WriterWithEncoder<Mesh | MeshArrowTable | Table, never, OBJWriterOptions>;
 
 /** Encode mesh category data as OBJ bytes. */
-function encodeOBJSync(data: Mesh | MeshArrowTable, options?: OBJWriterOptions): ArrayBuffer {
+function encodeOBJSync(
+  data: Mesh | MeshArrowTable | Table,
+  options?: OBJWriterOptions
+): ArrayBuffer {
   const text = encodeOBJ(data, options);
   return new TextEncoder().encode(text).buffer;
 }
 
 /** Encode mesh category data as OBJ text. */
-function encodeOBJ(data: Mesh | MeshArrowTable, options?: OBJWriterOptions): string {
+function encodeOBJ(data: Mesh | MeshArrowTable | Table, options?: OBJWriterOptions): string {
   const mesh = convertTableToMesh(normalizeMeshArrowTable(data));
   const positionAttribute = getRequiredAttribute(mesh, 'POSITION');
   const normalAttribute = mesh.attributes.NORMAL;
@@ -118,11 +122,11 @@ function encodeOBJ(data: Mesh | MeshArrowTable, options?: OBJWriterOptions): str
 }
 
 /** Return mesh data as a MeshArrowTable, converting plain Mesh data first. */
-function normalizeMeshArrowTable(data: Mesh | MeshArrowTable): MeshArrowTable {
-  if ('shape' in data && data.shape === 'arrow-table') {
+function normalizeMeshArrowTable(data: Mesh | MeshArrowTable | Table): MeshArrowTable | Table {
+  if (!('attributes' in data)) {
     return data;
   }
-  return convertMeshToTable(data as Mesh, 'arrow-table');
+  return convertMeshToArrowTableWrapper(data as Mesh);
 }
 
 /** Return a required mesh attribute or throw a format-specific error. */

package/src/obj/unbundled.ts

@@ -4,7 +4,7 @@
 
 export {OBJFormat} from './obj-format';
 export type {OBJLoaderOptions} from './obj-loader-types';
-export {OBJWorkerLoader, OBJLoader} from './obj-loader-types';
+export {OBJLoader} from './obj-loader-types';
 export {MTLFormat} from './mtl-format';
 export type {MTLLoaderOptions} from './mtl-loader-types';
-export {MTLWorkerLoader, MTLLoader} from './mtl-loader-types';
+export {MTLLoader} from './mtl-loader-types';

package/src/obj/workers/obj-worker.ts

@@ -3,22 +3,22 @@
 // Copyright (c) vis.gl contributors
 
 import {createLoaderWorker} from '@loaders.gl/core/loader-utils';
-import {OBJLoaderWithParser} from '../obj-loader';
+import {OBJColumnLoader} from '../obj-loader';
 
 createLoaderWorker({
-  ...OBJLoaderWithParser,
+  ...OBJColumnLoader,
   /** Always returns columnar data; legacy mesh conversion runs on the caller. */
   parse(input, options) {
-    return OBJLoaderWithParser.parse(input, {
+    return OBJColumnLoader.parse(input, {
       ...options,
-      obj: {...options?.obj, shape: 'arrow-table'}
+      obj: {...options?.obj, shape: 'arrow'}
     });
   },
   /** Keeps one columnar parser alive for the entire worker input stream. */
   parseInBatches(input, options) {
-    return OBJLoaderWithParser.parseInBatches(input, {
+    return OBJColumnLoader.parseInBatches(input, {
       ...options,
-      obj: {...options?.obj, shape: 'arrow-table'}
+      obj: {...options?.obj, shape: 'arrow'}
     });
   }
 });

package/src/obj-loader-types.ts

@@ -0,0 +1 @@
+export * from './obj/obj-loader-types.js';

package/src/obj-loader.ts

@@ -0,0 +1 @@
+export * from './obj/obj-loader.js';

package/src/obj-writer.ts

@@ -0,0 +1 @@
+export * from './obj/obj-writer.js';

package/src/stl/parse-stl.ts

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// loaders.gl
+import type {Mesh} from '@loaders.gl/core/schema';
+import {deduceMeshSchema, getMeshBoundingBox} from '@loaders.gl/core/schema-utils';
+
+/** Parses ASCII or little-endian binary STL without changing authored normals. */
+export function parseSTL(data: ArrayBuffer): Mesh {
+  const view = new DataView(data);
+  const binary = data.byteLength >= 84 && 84 + view.getUint32(80, true) * 50 === data.byteLength;
+  let positions: Float32Array;
+  let normals: Float32Array;
+  let header: string;
+  if (binary) {
+    const triangleCount = view.getUint32(80, true);
+    positions = new Float32Array(triangleCount * 9);
+    normals = new Float32Array(triangleCount * 9);
+    header = new TextDecoder().decode(data.slice(0, 80));
+    for (let triangle = 0; triangle < triangleCount; triangle++) {
+      const offset = 84 + triangle * 50;
+      for (let component = 0; component < 9; component++) {
+        positions[triangle * 9 + component] = view.getFloat32(offset + 12 + component * 4, true);
+        normals[triangle * 9 + component] = view.getFloat32(offset + (component % 3) * 4, true);
+      }
+    }
+  } else {
+    const lines = new TextDecoder()
+      .decode(data)
+      .trim()
+      .split(/\r?\n/)
+      .map(line => line.trim())
+      .filter(Boolean);
+    const vertices: number[] = [];
+    const normalValues: number[] = [];
+    header = lines[0] || '';
+    let lineIndex = 0;
+    while (lineIndex < lines.length) {
+      if (!/^solid(?:\s|$)/i.test(lines[lineIndex++]))
+        throw new Error('STL: expected solid header or exact binary length');
+      while (lineIndex < lines.length && !/^endsolid(?:\s|$)/i.test(lines[lineIndex])) {
+        const normal = parseVector(lines[lineIndex++], 'facet normal');
+        if (!/^outer\s+loop$/i.test(lines[lineIndex++] || ''))
+          throw new Error('STL: expected outer loop');
+        for (let vertex = 0; vertex < 3; vertex++) {
+          vertices.push(...parseVector(lines[lineIndex++], 'vertex'));
+          normalValues.push(...normal);
+        }
+        if (
+          !/^endloop$/i.test(lines[lineIndex++] || '') ||
+          !/^endfacet$/i.test(lines[lineIndex++] || '')
+        )
+          throw new Error('STL: incomplete facet');
+      }
+      if (lineIndex >= lines.length) throw new Error('STL: missing endsolid');
+      lineIndex++;
+    }
+    if (!lines.length) throw new Error('STL: empty input');
+    positions = new Float32Array(vertices);
+    normals = new Float32Array(normalValues);
+  }
+  if (!positions.every(Number.isFinite) || !normals.every(Number.isFinite))
+    throw new Error('STL: non-finite coordinates');
+  const attributes = {POSITION: {value: positions, size: 3}, NORMAL: {value: normals, size: 3}};
+  return {
+    topology: 'triangle-list',
+    mode: 4,
+    attributes,
+    schema: deduceMeshSchema(attributes),
+    header: {
+      vertexCount: positions.length / 3,
+      boundingBox: getMeshBoundingBox(attributes) ?? undefined
+    },
+    loaderData: {header, format: binary ? 'binary' : 'ascii'}
+  };
+}
+
+/** Reads exactly three finite decimal components after an ASCII record prefix. */
+function parseVector(line: string | undefined, prefix: string): number[] {
+  const tokens = line?.split(/\s+/) || [];
+  const prefixTokens = prefix.split(' ');
+  const components = tokens.slice(prefixTokens.length);
+  if (
+    prefixTokens.some((token, index) => tokens[index]?.toLowerCase() !== token) ||
+    components.length !== 3 ||
+    components.some(value => !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(value))
+  ) {
+    throw new Error(`STL: invalid ${prefix} record`);
+  }
+  return components.map(Number);
+}