minidraco 0.1.0

package/dist/three.d.ts

@@ -0,0 +1,177 @@
+import { Loader, BufferGeometry, LoadingManager, BufferAttribute } from 'three';
+
+declare class DataBuffer {
+    _data: Uint8Array;
+    constructor();
+    update(data: Uint8Array | ArrayBufferView | ArrayBuffer | null | undefined, size: number, offset?: number): boolean;
+    resize(newSize: number): void;
+    write(bytePos: number, inArray: Uint8Array | ArrayBufferView | ArrayBuffer, dataSize: number): void;
+    get data(): Uint8Array;
+    get dataSize(): number;
+    _resize(newSize: number): void;
+}
+
+declare class GeometryAttribute {
+    _buffer: DataBuffer | null;
+    _numComponents: number;
+    _dataType: number;
+    _normalized: boolean;
+    _byteStride: number;
+    _byteOffset: number;
+    _attributeType: number;
+    _uniqueId: number;
+    constructor();
+    init(attributeType: number, buffer: DataBuffer | null, numComponents: number, dataType: number, normalized: boolean, byteStride: number, byteOffset: number): void;
+    getAddress(attIndex: number): Uint8Array;
+    copyFrom(srcAtt: GeometryAttribute): boolean;
+    resetBuffer(buffer: DataBuffer, byteStride: number, byteOffset: number): void;
+    get attributeType(): number;
+    get dataType(): number;
+    get numComponents(): number;
+    get buffer(): DataBuffer | null;
+    get byteStride(): number;
+    get byteOffset(): number;
+    get uniqueId(): number;
+    set uniqueId(id: number);
+}
+
+declare class AttributeTransformData {
+    _transformType: number;
+    _buffer: DataBuffer;
+    constructor();
+    get transformType(): number;
+    set transformType(type: number);
+    setParameterValue(byteOffset: number, value: number, type: string): void;
+    appendParameterValue(value: number, type: string): void;
+    _typeSize(type: string): number;
+}
+
+type ExtractTypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+declare class PointAttribute extends GeometryAttribute {
+    _identityMapping: boolean;
+    _numUniqueEntries: number;
+    _indicesMap: number[] | Uint32Array;
+    _attributeBuffer: DataBuffer | null;
+    _attributeTransformData: AttributeTransformData | null;
+    _cachedFloat32View?: Float32Array;
+    _cachedFloat32Buffer?: ArrayBufferLike;
+    _cachedInt32View?: Int32Array;
+    _cachedInt32Buffer?: ArrayBufferLike;
+    _cachedUint32View?: Uint32Array;
+    _cachedUint32Buffer?: ArrayBufferLike;
+    _cachedUint16View?: Uint16Array;
+    _cachedUint16Buffer?: ArrayBufferLike;
+    _cachedInt16View?: Int16Array;
+    _cachedInt16Buffer?: ArrayBufferLike;
+    _cachedUint8View?: Uint8Array;
+    _cachedUint8Buffer?: ArrayBufferLike;
+    _cachedInt8View?: Int8Array;
+    _cachedInt8Buffer?: ArrayBufferLike;
+    _cachedFloat64View?: Float64Array;
+    _cachedFloat64Buffer?: ArrayBufferLike;
+    _cachedDataView?: DataView;
+    _cachedDVBuffer?: ArrayBufferLike;
+    constructor(geometryAttribute?: GeometryAttribute);
+    init(attributeType: number, numComponents: number, dataType: number, normalized: boolean, numAttributeValues: number): void;
+    reset(numAttributeValues: number): boolean;
+    get size(): number;
+    mappedIndex(pointIndex: number): number;
+    get isMappingIdentity(): boolean;
+    get indicesMapSize(): number;
+    get indicesMap(): number[] | Uint32Array;
+    setIdentityMapping(): void;
+    setExplicitMapping(numPoints: number): void;
+    setExplicitMappingUnfilled(numPoints: number): void;
+    setAttributeTransformData(transformData: AttributeTransformData): void;
+    convertValue(attIndex: number, outVal: number[] | Int32Array | Uint32Array | Float32Array | Float64Array): void;
+    extractTo<C extends new (length: number) => ExtractTypedArray>(OutputTypedArray: C, numPoints: number): InstanceType<C>;
+    copyFrom(srcAtt: PointAttribute): void;
+}
+
+declare class PointCloud {
+    num_points_: number;
+    attributes_: (PointAttribute | null)[];
+    named_attribute_index_: number[][];
+    constructor();
+    numNamedAttributes(type: number): number;
+    getNamedAttributeId(type: number, i?: number): number;
+    getNamedAttribute(type: number, i?: number): PointAttribute | null;
+    getAttributeByUniqueId(uniqueId: number): PointAttribute | null;
+    getAttributeIdByUniqueId(uniqueId: number): number;
+    numAttributes(): number;
+    attribute(attId: number): PointAttribute;
+    addAttribute(pa: PointAttribute): number;
+    setAttribute(attId: number, pa: PointAttribute): void;
+    numPoints(): number;
+    setNumPoints(num: number): void;
+}
+
+declare class Mesh extends PointCloud {
+    faces_: Int32Array;
+    numFaces_: number;
+    attribute_data_: {
+        elementType: number;
+    }[];
+    constructor();
+    _ensureFaceCapacity(numFaces: number): void;
+    addFace(face: ArrayLike<number>): void;
+    setNumFaces(numFaces: number): void;
+    numFaces(): number;
+    face(faceId: number): number[];
+    setAttribute(attId: number, pa: PointAttribute): void;
+}
+
+type AttributeIDs = Record<string, number | string>;
+type AttributeTypes = Record<string, string>;
+interface TaskConfig {
+    attributeIDs: AttributeIDs;
+    attributeTypes: AttributeTypes;
+    useUniqueIDs: boolean;
+    vertexColorSpace: string;
+}
+interface RawAttribute {
+    name: string;
+    array: Float32Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array;
+    itemSize: number;
+}
+interface RawGeometry {
+    indices: Uint32Array;
+    attributes: RawAttribute[];
+}
+interface WorkerEntry {
+    worker: Worker;
+    pending: number;
+}
+declare class MiniDRACOLoader extends Loader<BufferGeometry> {
+    defaultAttributeIDs: AttributeIDs;
+    defaultAttributeTypes: AttributeTypes;
+    workerLimit: number;
+    _workers: WorkerEntry[];
+    _taskId: number;
+    _tasks: Map<number, {
+        resolve: (raw: RawGeometry) => void;
+        reject: (error: unknown) => void;
+        entry: WorkerEntry;
+    }>;
+    _workersBroken: boolean;
+    constructor(manager?: LoadingManager);
+    setDecoderPath(_path?: string): this;
+    setDecoderConfig(_config?: object): this;
+    setWorkerLimit(limit: number): this;
+    preload(): this;
+    dispose(): this;
+    load(url: string, onLoad: (geometry: BufferGeometry) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+    parse(buffer: ArrayBuffer, onLoad: (geometry: BufferGeometry) => void, onError?: (err: unknown) => void): void;
+    decodeDracoFile(buffer: ArrayBuffer, callback?: (geometry: BufferGeometry) => void, attributeIDs?: AttributeIDs | null, attributeTypes?: AttributeTypes | null, vertexColorSpace?: string, onError?: (err: unknown) => void): Promise<BufferGeometry | void>;
+    decodeGeometry(buffer: ArrayBuffer, taskConfig: TaskConfig): Promise<BufferGeometry>;
+    _runTask(buffer: ArrayBuffer, taskConfig: TaskConfig): Promise<BufferGeometry>;
+    _workersAvailable(): boolean;
+    _getWorker(): WorkerEntry;
+    _decodeInWorker(buffer: ArrayBuffer, taskConfig: TaskConfig): Promise<RawGeometry>;
+    _buildGeometryFromRaw(raw: RawGeometry, taskConfig: TaskConfig): BufferGeometry;
+    _decodeBuffer(buffer: ArrayBuffer, taskConfig: TaskConfig): BufferGeometry;
+    _buildGeometry(dracoGeometry: Mesh, taskConfig: TaskConfig): BufferGeometry;
+    _assignVertexColorSpace(attribute: BufferAttribute, inputColorSpace: string): void;
+}
+
+export { type AttributeIDs, type AttributeTypes, MiniDRACOLoader as DRACOLoader, MiniDRACOLoader };