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

package/src/draco/draco3d/draco3d-types.ts

@@ -0,0 +1,498 @@
+// SPDX-License-Identifier: Apache-2.0
+
+// A set of typescript types manually adapted from the Draco 1.5.7 web IDL.
+// Draco JS is a bit tricky to work with due to the C++ emscripten code base
+// sparse documentation, so these types provide an extra safety net.
+
+// Typescript defs adapted from the release-pinned draco3d emscripten IDL:
+// https://raw.githubusercontent.com/google/draco/8786740086a9f4d83f44aa83badfbea4dce7a1b5/src/draco/javascript/emscripten/draco_web_decoder.idl
+// https://raw.githubusercontent.com/google/draco/8786740086a9f4d83f44aa83badfbea4dce7a1b5/src/draco/javascript/emscripten/draco_web_encoder.idl
+// Interface exposed to emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+
+/* eslint-disable camelcase */
+
+/** Byte offset into Draco's WebAssembly memory. */
+type VoidPtr = number;
+
+// DRACO WEB DECODER IDL
+
+/** Draco3D geometry attribute type */
+export enum draco_GeometryAttribute_Type {
+  'draco_GeometryAttribute::INVALID',
+  'draco_GeometryAttribute::POSITION',
+  'draco_GeometryAttribute::NORMAL',
+  'draco_GeometryAttribute::COLOR',
+  'draco_GeometryAttribute::TEX_COORD',
+  'draco_GeometryAttribute::GENERIC'
+}
+
+/** Draco3D encoded geometry type */
+export enum draco_EncodedGeometryType {
+  'draco::INVALID_GEOMETRY_TYPE',
+  'draco::POINT_CLOUD',
+  'draco::TRIANGULAR_MESH'
+}
+
+/** Draco3D data type */
+export enum draco_DataType {
+  'draco::DT_INVALID',
+  'draco::DT_INT8',
+  'draco::DT_UINT8',
+  'draco::DT_INT16',
+  'draco::DT_UINT16',
+  'draco::DT_INT32',
+  'draco::DT_UINT32',
+  'draco::DT_INT64',
+  'draco::DT_UINT64',
+  'draco::DT_FLOAT32',
+  'draco::DT_FLOAT64',
+  'draco::DT_BOOL',
+  'draco::DT_TYPES_COUNT'
+}
+
+/** Draco3D status code */
+export enum draco_StatusCode {
+  'draco_Status::OK',
+  'draco_Status::DRACO_ERROR',
+  'draco_Status::IO_ERROR',
+  'draco_Status::INVALID_PARAMETER',
+  'draco_Status::UNSUPPORTED_VERSION',
+  'draco_Status::UNKNOWN_VERSION'
+}
+
+/** Draco3D decoder buffer allocated on emscripten heap */
+export declare class DecoderBuffer {
+  constructor();
+  Init(data: Int8Array, data_size: number): void;
+}
+
+/** Draco3D attribute transform data */
+export declare class AttributeTransformData {
+  constructor();
+  transform_type(): number;
+}
+
+/** Draco3D geometry attribute */
+export declare class GeometryAttribute {
+  constructor();
+}
+
+/** Draco3D point attribute */
+export declare class PointAttribute {
+  ptr: VoidPtr;
+
+  constructor();
+  size(): number;
+  GetAttributeTransformData(): AttributeTransformData;
+
+  // From GeometryAttribute
+  attribute_type(): number;
+  data_type(): number;
+  num_components(): number;
+  normalized(): boolean;
+  byte_stride(): number;
+  byte_offset(): number;
+  unique_id(): number;
+}
+
+/** Draco3D attribute transform */
+export declare class AttributeQuantizationTransform {
+  constructor();
+  InitFromAttribute(att: PointAttribute): boolean;
+  quantization_bits(): number;
+  min_value(axis: number): number;
+  range(): number;
+}
+
+/** Draco3D attribute transform */
+export declare class AttributeOctahedronTransform {
+  constructor();
+  InitFromAttribute(att: PointAttribute): boolean;
+  quantization_bits(): number;
+}
+
+/** Draco3D point cloud */
+export declare class PointCloud {
+  ptr: VoidPtr;
+
+  constructor();
+  num_attributes(): number;
+  num_points(): number;
+}
+
+/** Draco3D mesh */
+export declare class Mesh extends PointCloud {
+  constructor();
+  num_faces(): number;
+}
+
+/** Draco3D metadata */
+export declare class Metadata {
+  ptr: VoidPtr;
+
+  constructor();
+}
+
+/** Draco3D status */
+export declare class Status {
+  constructor();
+  code(): draco_StatusCode;
+  ok(): boolean;
+  error_msg(): string;
+}
+
+/** Draco3D Float32Array allocated on the emscripten heap */
+export declare class DracoFloat32Array {
+  constructor();
+  GetValue(index: number): number;
+  size(): number;
+}
+
+/** Draco3D Int8Array allocated on the emscripten heap */
+export declare class DracoInt8Array {
+  constructor();
+  GetValue(index: number): number;
+  size(): number;
+}
+
+/** Draco3D Uint8Array allocated on the emscripten heap */
+export declare class DracoUInt8Array {
+  GetValue(index: number): number;
+  size(): number;
+}
+
+/** Draco3D Int16Array allocated on the emscripten heap */
+export declare class DracoInt16Array {
+  constructor();
+  GetValue(index: number): number;
+  size(): number;
+}
+
+/** Draco3D Uint16Array allocated on the emscripten heap */
+export declare class DracoUInt16Array {
+  constructor();
+  GetValue(index: number): number;
+  size(): number;
+}
+
+/** Draco3D Int32Array allocated on the emscripten heap */
+export declare class DracoInt32Array {
+  constructor();
+  GetValue(index: number): number;
+  size(): number;
+}
+
+/** Draco3D Uint32Array allocated on the emscripten heap */
+export declare class DracoUInt32Array {
+  constructor();
+  GetValue(index: number): number;
+  size(): number;
+}
+
+/** Draco3D metadata querier */
+export declare class MetadataQuerier {
+  constructor();
+
+  HasEntry(metadata: Metadata, entry_name: string): string;
+  GetIntEntry(metadata: Metadata, entry_name: string);
+  GetIntEntryArray(metadata: Metadata, entry_name: string, out_values: DracoInt32Array);
+  GetDoubleEntry(metadata: Metadata, entry_name: string): number;
+  GetStringEntry(metadata: Metadata, entry_name: string): string;
+
+  NumEntries(metadata: Metadata): number;
+  GetEntryName(metadata: Metadata, entry_id: number): string;
+}
+
+/**
+ * Draco3D Decoder class
+ */
+export declare class Decoder {
+  constructor();
+
+  GetEncodedGeometryType(data: Int8Array): draco_EncodedGeometryType;
+
+  DecodeArrayToPointCloud(data: Int8Array, data_size: number, out_point_cloud: PointCloud): Status;
+  DecodeArrayToMesh(data: Int8Array, data_size: number, out_mesh: Mesh): Status;
+
+  /** @deprecated Use `DecodeArrayToPointCloud`. */
+  DecodeBufferToPointCloud(in_buffer: DecoderBuffer, out_point_cloud: PointCloud): Status;
+  /** @deprecated Use `DecodeArrayToMesh`. */
+  DecodeBufferToMesh(in_buffer: DecoderBuffer, out_mesh: Mesh): Status;
+
+  GetAttributeId(pc: PointCloud, type: draco_GeometryAttribute_Type): number;
+  GetAttributeIdByName(pc: PointCloud, name: string): number;
+  GetAttributeIdByMetadataEntry(pc: PointCloud, name: string, value: string): number;
+
+  GetAttribute(pc: PointCloud, att_id: number): PointAttribute;
+  GetAttributeByUniqueId(pc: PointCloud, unique_id: number): PointAttribute;
+
+  GetMetadata(pc: PointCloud): Metadata;
+  GetAttributeMetadata(pc: PointCloud, att_id: number): Metadata;
+
+  GetFaceFromMesh(m: Mesh, face_id: number, out_values: DracoInt32Array): boolean;
+  GetTriangleStripsFromMesh(m: Mesh, strip_values: DracoInt32Array);
+
+  GetTrianglesUInt16Array(m: Mesh, out_size: number, out_values: VoidPtr): boolean;
+  GetTrianglesUInt32Array(m: Mesh, out_size: number, out_values: VoidPtr): boolean;
+
+  GetAttributeFloat(pa: PointAttribute, att_index: number, out_values: DracoFloat32Array): boolean;
+
+  GetAttributeFloatForAllPoints(
+    pc: PointCloud,
+    pa: PointAttribute,
+    out_values: DracoFloat32Array
+  ): boolean;
+
+  // Deprecated, use GetAttributeInt32ForAllPoints instead.
+  GetAttributeIntForAllPoints(
+    pc: PointCloud,
+    pa: PointAttribute,
+    out_values: DracoInt32Array
+  ): boolean;
+
+  GetAttributeInt8ForAllPoints(
+    pc: PointCloud,
+    pa: PointAttribute,
+    out_values: DracoInt8Array
+  ): boolean;
+  GetAttributeUInt8ForAllPoints(
+    pc: PointCloud,
+    pa: PointAttribute,
+    out_values: DracoUInt8Array
+  ): boolean;
+  GetAttributeInt16ForAllPoints(
+    pc: PointCloud,
+    pa: PointAttribute,
+    out_values: DracoInt16Array
+  ): boolean;
+  GetAttributeUInt16ForAllPoints(
+    pc: PointCloud,
+    pa: PointAttribute,
+    out_values: DracoUInt16Array
+  ): boolean;
+  GetAttributeInt32ForAllPoints(
+    pc: PointCloud,
+    pa: PointAttribute,
+    out_values: DracoInt32Array
+  ): boolean;
+  GetAttributeUInt32ForAllPoints(
+    pc: PointCloud,
+    pa: PointAttribute,
+    out_values: DracoUInt32Array
+  ): boolean;
+
+  GetAttributeDataArrayForAllPoints(
+    pc: PointCloud,
+    pa: PointAttribute,
+    data_type: draco_DataType,
+    out_size: number,
+    out_values: VoidPtr
+  ): boolean;
+
+  SkipAttributeTransform(att_type: draco_GeometryAttribute_Type): void;
+}
+
+// DRACO WEB ENCODER IDL
+
+/** Draco3D metadata builder */
+export declare class MetadataBuilder {
+  constructor();
+  AddStringEntry(metadata: Metadata, entry_name: string, entry_value: string);
+  AddIntEntry(metadata: Metadata, entry_name: string, entry_value: number);
+  AddDoubleEntry(metadata: Metadata, entry_name: string, entry_value: number);
+  AddIntEntryArray(
+    metadata: Metadata,
+    entry_name: string,
+    entry_value: Int32Array,
+    num_values: number
+  );
+}
+
+/** Draco3D point cloud builder */
+
+export declare class PointCloudBuilder {
+  constructor();
+  PointCloudBuilder(): void;
+  AddFloatAttribute(
+    pc: PointCloud,
+    type: draco_GeometryAttribute_Type,
+    num_vertices: number,
+    num_components: number,
+    att_values: Float32Array
+  );
+  AddInt8Attribute(
+    pc: PointCloud,
+    type: draco_GeometryAttribute_Type,
+    num_vertices: number,
+    num_components: number,
+    att_values: Int8Array
+  );
+  AddUInt8Attribute(
+    pc: PointCloud,
+    type: draco_GeometryAttribute_Type,
+    num_vertices: number,
+    num_components: number,
+    att_values: Uint8Array
+  );
+  AddInt16Attribute(
+    pc: PointCloud,
+    type: draco_GeometryAttribute_Type,
+    num_vertices: number,
+    num_components: number,
+    att_values: Int16Array
+  );
+  AddUInt16Attribute(
+    pc: PointCloud,
+    type: draco_GeometryAttribute_Type,
+    num_vertices: number,
+    num_components: number,
+    att_values: Uint16Array
+  );
+  AddInt32Attribute(
+    pc: PointCloud,
+    type: draco_GeometryAttribute_Type,
+    num_vertices: number,
+    num_components: number,
+    att_values: Int32Array
+  );
+  AddUInt32Attribute(
+    pc: PointCloud,
+    type: draco_GeometryAttribute_Type,
+    num_vertices: number,
+    num_components: number,
+    att_values: Uint32Array
+  );
+
+  AddMetadata(pc: PointCloud, metadata: Metadata): boolean;
+  SetMetadataForAttribute(pc: PointCloud, attribute_id: number, metadata: Metadata);
+  SetNormalizedFlagForAttribute(pc: PointCloud, attribute_id: number, normalized: boolean): boolean;
+}
+
+/** Draco3D mesh builder */
+export declare class MeshBuilder extends PointCloudBuilder {
+  constructor();
+  AddFacesToMesh(mesh: Mesh, num_faces: number, faces: Uint16Array | Uint32Array): boolean;
+}
+
+/** Draco3D encoder */
+export declare class Encoder {
+  constructor();
+  Encoder(): void;
+  SetEncodingMethod(method: number): void;
+  SetAttributeQuantization(type: draco_GeometryAttribute_Type, quantization_bits: number);
+  SetAttributeExplicitQuantization(
+    type: draco_GeometryAttribute_Type,
+    quantization_bits: number,
+    num_components: number,
+    origin: number[],
+    range: number
+  );
+  SetSpeedOptions(encoding_speed: number, decoding_speed: number): void;
+  SetTrackEncodedProperties(flag: boolean): void;
+
+  EncodeMeshToDracoBuffer(mesh: Mesh, encoded_data: DracoInt8Array);
+  EncodePointCloudToDracoBuffer(
+    pc: PointCloud,
+    deduplicate_values: boolean,
+    encoded_data: DracoInt8Array
+  );
+
+  // Returns the number of encoded points or faces from the last Encode
+  // operation. Returns 0 if SetTrackEncodedProperties was not set to true.
+  GetNumberOfEncodedPoints(): number;
+  GetNumberOfEncodedFaces(): number;
+}
+
+/** Draco3D expert encoder */
+export declare class ExpertEncoder {
+  constructor(pointCloud: PointCloud);
+  SetEncodingMethod(method: number): void;
+  SetAttributeQuantization(att_id: number, quantization_bits: number);
+  SetAttributeExplicitQuantization(
+    att_id: number,
+    quantization_bits: number,
+    num_components: number,
+    origin: number[],
+    range: number
+  );
+  SetSpeedOptions(encoding_speed: number, decoding_speed: number): void;
+  SetTrackEncodedProperties(flag: boolean): void;
+
+  EncodeToDracoBuffer(deduplicate_values: boolean, encoded_data: DracoInt8Array);
+
+  // Returns the number of encoded points or faces from the last Encode
+  // operation. Returns 0 if SetTrackEncodedProperties was not set to true.
+  GetNumberOfEncodedPoints(): number;
+  GetNumberOfEncodedFaces(): number;
+}
+
+/** Draco3D module interface */
+export interface Draco3D {
+  // ENUMS
+
+  // draco_EncodedGeometryType
+  readonly INVALID_GEOMETRY_TYPE: draco_EncodedGeometryType;
+  readonly POINT_CLOUD: draco_EncodedGeometryType;
+  readonly TRIANGULAR_MESH: draco_EncodedGeometryType;
+
+  // enum draco_GeometryAttribute_Type
+  readonly INVALID: draco_GeometryAttribute_Type;
+  readonly POSITION: draco_GeometryAttribute_Type;
+  readonly NORMAL: draco_GeometryAttribute_Type;
+  readonly COLOR: draco_GeometryAttribute_Type;
+  readonly TEX_COORD: draco_GeometryAttribute_Type;
+  readonly GENERIC: draco_GeometryAttribute_Type;
+
+  readonly MESH_SEQUENTIAL_ENCODING: number;
+  readonly MESH_EDGEBREAKER_ENCODING: number;
+
+  // enum draco_DataType
+  readonly DT_INVALID: draco_DataType;
+  readonly DT_INT8: draco_DataType;
+  readonly DT_UINT8: draco_DataType;
+  readonly DT_INT16: draco_DataType;
+  readonly DT_UINT16: draco_DataType;
+  readonly DT_INT32: draco_DataType;
+  readonly DT_UINT32: draco_DataType;
+  readonly DT_INT64: draco_DataType;
+  readonly DT_UINT64: draco_DataType;
+  readonly DT_FLOAT32: draco_DataType;
+  readonly DT_FLOAT64: draco_DataType;
+  readonly DT_BOOL: draco_DataType;
+  readonly DT_TYPES_COUNT: draco_DataType;
+
+  readonly Mesh: typeof Mesh;
+  readonly PointCloud: typeof PointCloud;
+  readonly Metadata: typeof Metadata;
+
+  readonly Encoder: typeof Encoder;
+  readonly ExpertEncoder: typeof ExpertEncoder;
+  readonly MeshBuilder: typeof MeshBuilder;
+  readonly MetadataBuilder: typeof MetadataBuilder;
+
+  readonly MetadataQuerier: typeof MetadataQuerier;
+  readonly Decoder: typeof Decoder;
+  readonly DecoderBuffer: typeof DecoderBuffer;
+
+  readonly DracoFloat32Array: typeof DracoFloat32Array;
+  readonly DracoInt8Array: typeof DracoInt8Array;
+  readonly DracoUInt8Array: typeof DracoUInt8Array;
+  readonly DracoInt16Array: typeof DracoInt16Array;
+  readonly DracoUInt16Array: typeof DracoUInt16Array;
+  readonly DracoInt32Array: typeof DracoInt32Array;
+  readonly DracoUInt32Array: typeof DracoUInt32Array;
+
+  readonly AttributeQuantizationTransform: typeof AttributeQuantizationTransform;
+  readonly AttributeOctahedronTransform: typeof AttributeOctahedronTransform;
+
+  // createEncoderModule(): Encoder;
+  // createDecoderModule(): Decoder;
+  destroy(resource: object): void;
+  _malloc(byteLength: number): number;
+  _free(ptr: number): void;
+
+  HEAPU8: {
+    buffer: ArrayBuffer;
+  };
+}

package/src/draco/draco3d-loader-with-parser.ts

@@ -0,0 +1,34 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderWithParser, LoaderContext} from '@loaders.gl/core/loader-utils';
+import type {Table} from 'apache-arrow';
+import type {DracoMesh} from './lib/draco-types';
+import {loadDracoDecoderModuleFromDraco3D} from './lib/draco-module-loader';
+import {parseDraco} from './lib/parse-draco';
+import {DracoLoader as DracoLoaderMetadata} from './draco-loader-types';
+import type {DracoLoaderOptions} from './draco-loader-options';
+
+const {preload: _DracoLoaderPreload, ...DracoLoaderMetadataWithoutPreload} = DracoLoaderMetadata;
+
+/** Parser-bearing Draco loader backed by an injected `draco3d` package. */
+export const Draco3DLoaderWithParser = {
+  ...DracoLoaderMetadataWithoutPreload,
+  parse: async (arrayBuffer: ArrayBuffer, options?: DracoLoaderOptions, context?: LoaderContext) =>
+    await parseDraco(
+      arrayBuffer,
+      options,
+      async () => await loadDracoDecoderModuleFromDraco3D(getDraco3DModule(options)),
+      context
+    )
+} as const satisfies LoaderWithParser<DracoMesh | Table, never, DracoLoaderOptions>;
+
+/** Extracts the injected `draco3d` package from loader options. */
+function getDraco3DModule(options?: DracoLoaderOptions): unknown {
+  const draco3DModule = options?.modules?.draco3d;
+  if (!draco3DModule) {
+    throw new Error('DracoLoader: backend "draco3d" requires options.modules.draco3d');
+  }
+  return draco3DModule;
+}

package/src/draco/index.ts

@@ -0,0 +1,42 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// Module constants
+export {DRACO_EXTERNAL_LIBRARIES, DRACO_EXTERNAL_LIBRARY_URLS} from './lib/draco-module-loader';
+export type {DracoDecoderProfile} from './lib/draco-module-loader';
+
+// Draco data types
+
+export type {DracoMesh, DracoLoaderData} from './lib/draco-types';
+export {DracoFormat} from './draco-format';
+
+// Draco Writer
+
+export type {
+  DracoBatchOptions,
+  DracoBatchProgress,
+  DracoWriterAttributes,
+  DracoWriterInput,
+  DracoWriterInputBatch,
+  DracoWriterOptions
+} from './draco-writer';
+export {encodeDraco, encodeDracoBatch, encodeDracoInBatches} from './draco-writer';
+export type {
+  DracoAttributeQuantization,
+  DracoAttributeType,
+  DracoBuilderMesh,
+  DracoBuildOptions,
+  DracoEncodingMethod,
+  DracoEncodingAttributeReport,
+  DracoEncodingReport,
+  DracoEncodingResult,
+  DracoExplicitQuantization,
+  DracoMetadata
+} from './lib/draco-builder';
+export {DracoWriterWorker, DracoWriter} from './draco-writer';
+
+// Draco Loader
+
+export type {DracoLoaderOptions} from './draco-loader-types';
+export {DracoLoader} from './draco-loader-types';