@sparkjsdev/spark 0.1.0

package/dist/types/ForgeRenderer.d.ts

@@ -0,0 +1,136 @@
+import { ForgeViewpoint, ForgeViewpointOptions } from './ForgeViewpoint';
+import { RgbaArray } from './RgbaArray';
+import { SplatAccumulator } from './SplatAccumulator';
+import { SplatGenerator } from './SplatGenerator';
+import * as THREE from "three";
+export type ForgeRendererOptions = {
+    renderer: THREE.WebGLRenderer;
+    clock?: THREE.Clock;
+    autoUpdate?: boolean;
+    preUpdate?: boolean;
+    originDistance?: number;
+    maxStdDev?: number;
+    enable2DGS?: boolean;
+    preBlurAmount?: number;
+    blurAmount?: number;
+    falloff?: number;
+    clipXY?: number;
+    view?: ForgeViewpointOptions;
+};
+export declare class ForgeRenderer extends THREE.Mesh {
+    renderer: THREE.WebGLRenderer;
+    material: THREE.ShaderMaterial;
+    uniforms: ReturnType<typeof ForgeRenderer.makeUniforms>;
+    autoUpdate: boolean;
+    preUpdate: boolean;
+    originDistance: number;
+    maxStdDev: number;
+    enable2DGS: boolean;
+    preBlurAmount: number;
+    blurAmount: number;
+    falloff: number;
+    clipXY: number;
+    time?: number;
+    deltaTime?: number;
+    clock: THREE.Clock;
+    active: SplatAccumulator;
+    private freeAccumulators;
+    private accumulatorCount;
+    defaultView: ForgeViewpoint;
+    autoViewpoints: ForgeViewpoint[];
+    private rotateToAccumulator;
+    private translateToAccumulator;
+    private modifier;
+    private lastFrame;
+    private lastUpdateTime;
+    private defaultCameras;
+    viewpoint: ForgeViewpoint;
+    private pendingUpdate;
+    private envViewpoint;
+    private static cubeRender;
+    private static pmrem;
+    constructor(options: ForgeRendererOptions);
+    static makeUniforms(): {
+        renderSize: {
+            value: THREE.Vector2;
+        };
+        numSplats: {
+            value: number;
+        };
+        renderToViewQuat: {
+            value: THREE.Quaternion;
+        };
+        renderToViewPos: {
+            value: THREE.Vector3;
+        };
+        maxStdDev: {
+            value: number;
+        };
+        enable2DGS: {
+            value: boolean;
+        };
+        preBlurAmount: {
+            value: number;
+        };
+        blurAmount: {
+            value: number;
+        };
+        falloff: {
+            value: number;
+        };
+        clipXY: {
+            value: number;
+        };
+        packedSplats: {
+            type: string;
+            value: THREE.DataArrayTexture;
+        };
+        time: {
+            value: number;
+        };
+        deltaTime: {
+            value: number;
+        };
+        encodeLinear: {
+            value: boolean;
+        };
+        debugFlag: {
+            value: boolean;
+        };
+    };
+    private canAllocAccumulator;
+    private maybeAllocAccumulator;
+    releaseAccumulator(accumulator: SplatAccumulator): void;
+    newViewpoint(options: ForgeViewpointOptions): ForgeViewpoint;
+    onBeforeRender(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera): void;
+    prepareViewpoint(viewpoint?: ForgeViewpoint): void;
+    update({ scene, viewToWorld, }: {
+        scene: THREE.Scene;
+        viewToWorld?: THREE.Matrix4;
+    }): void;
+    updateInternal({ scene, originToWorld, viewToWorld, }: {
+        scene: THREE.Scene;
+        originToWorld?: THREE.Matrix4;
+        viewToWorld?: THREE.Matrix4;
+    }): boolean;
+    private compileScene;
+    renderEnvMap({ renderer, scene, worldCenter, size, near, far, hideObjects, update, }: {
+        renderer?: THREE.WebGLRenderer;
+        scene: THREE.Scene;
+        worldCenter: THREE.Vector3;
+        size?: number;
+        near?: number;
+        far?: number;
+        hideObjects?: THREE.Object3D[];
+        update?: boolean;
+    }): Promise<THREE.Texture>;
+    recurseSetEnvMap(root: THREE.Object3D, envMap: THREE.Texture): void;
+    getRgba({ generator, rgba, }: {
+        generator: SplatGenerator;
+        rgba?: RgbaArray;
+    }): RgbaArray;
+    readRgba({ generator, rgba, }: {
+        generator: SplatGenerator;
+        rgba?: RgbaArray;
+    }): Promise<Uint8Array>;
+}

package/dist/types/ForgeViewpoint.d.ts

@@ -0,0 +1,83 @@
+import { ForgeRenderer } from './ForgeRenderer';
+import { SplatAccumulator } from './SplatAccumulator';
+import { SplatGeometry } from './SplatGeometry';
+import * as THREE from "three";
+export type ForgeViewpointOptions = {
+    autoUpdate?: boolean;
+    camera?: THREE.Camera;
+    viewToWorld?: THREE.Matrix4;
+    target?: {
+        width: number;
+        height: number;
+        doubleBuffer?: boolean;
+        superXY?: number;
+    };
+    onTextureUpdated?: (texture: THREE.Texture) => void;
+    sortRadial?: boolean;
+    sortDistance?: number;
+    sortCoorient?: boolean;
+    depthBias?: number;
+    sort360?: boolean;
+};
+export declare class ForgeViewpoint {
+    forge: ForgeRenderer;
+    autoUpdate: boolean;
+    camera?: THREE.Camera;
+    viewToWorld: THREE.Matrix4;
+    lastTime: number | null;
+    target?: THREE.WebGLRenderTarget;
+    private back?;
+    onTextureUpdated?: (texture: THREE.Texture) => void;
+    encodeLinear: boolean;
+    superXY: number;
+    private superPixels?;
+    private pixels?;
+    sortRadial: boolean;
+    sortDistance?: number;
+    sortCoorient?: boolean;
+    depthBias?: number;
+    sort360?: boolean;
+    display: {
+        accumulator: SplatAccumulator;
+        viewToWorld: THREE.Matrix4;
+        geometry: SplatGeometry;
+    } | null;
+    private sorting;
+    private pending;
+    private sortingCheck;
+    private readback;
+    private orderingFreelist;
+    constructor(options: ForgeViewpointOptions & {
+        forge: ForgeRenderer;
+    });
+    dispose(): void;
+    setAutoUpdate(autoUpdate: boolean): void;
+    prepare({ scene, camera, viewToWorld, update, forceOrigin, }: {
+        scene: THREE.Scene;
+        camera?: THREE.Camera;
+        viewToWorld?: THREE.Matrix4;
+        update?: boolean;
+        forceOrigin?: boolean;
+    }): Promise<void>;
+    renderTarget({ scene, camera, }: {
+        scene: THREE.Scene;
+        camera?: THREE.Camera;
+    }): void;
+    readTarget(): Promise<Uint8Array>;
+    prepareRenderPixels({ scene, camera, viewToWorld, update, forceOrigin, }: {
+        scene: THREE.Scene;
+        camera?: THREE.Camera;
+        viewToWorld?: THREE.Matrix4;
+        update?: boolean;
+        forceOrigin?: boolean;
+    }): Promise<Uint8Array<ArrayBufferLike>>;
+    autoPoll({ accumulator }: {
+        accumulator?: SplatAccumulator;
+    }): void;
+    private driveSort;
+    private sortUpdate;
+    private updateDisplay;
+    static EMPTY_TEXTURE: THREE.Texture;
+    private static dynos;
+    private static makeSorter;
+}

package/dist/types/PackedSplats.d.ts

@@ -0,0 +1,87 @@
+import { GsplatGenerator } from './SplatGenerator';
+import { SplatFileType } from './SplatLoader';
+import { DynoProgram, DynoProgramTemplate, DynoUniform } from './dyno';
+import { TPackedSplats } from './dyno/splats';
+import * as THREE from "three";
+export type PackedSplatsOptions = {
+    url?: string;
+    fileBytes?: Uint8Array | ArrayBuffer;
+    fileType?: SplatFileType;
+    fileName?: string;
+    maxSplats?: number;
+    packedArray?: Uint32Array;
+    numSplats?: number;
+    construct?: (splats: PackedSplats) => Promise<void> | void;
+    extra?: Record<string, unknown>;
+};
+export declare class PackedSplats {
+    maxSplats: number;
+    numSplats: number;
+    packedArray: Uint32Array | null;
+    extra: Record<string, unknown>;
+    initialized: Promise<PackedSplats>;
+    isInitialized: boolean;
+    target: THREE.WebGLArrayRenderTarget | null;
+    source: THREE.DataArrayTexture | null;
+    needsUpdate: boolean;
+    dyno: DynoUniform<typeof TPackedSplats, "packedSplats">;
+    constructor(options?: PackedSplatsOptions);
+    reinitialize(options: PackedSplatsOptions): void;
+    initialize(options: PackedSplatsOptions): void;
+    asyncInitialize(options: PackedSplatsOptions): Promise<void>;
+    dispose(): void;
+    ensureSplats(numSplats: number): Uint32Array;
+    ensureSplatsSh(level: number, numSplats: number): Uint32Array;
+    getSplat(index: number): {
+        center: THREE.Vector3;
+        scales: THREE.Vector3;
+        quaternion: THREE.Quaternion;
+        opacity: number;
+        color: THREE.Color;
+    };
+    setSplat(index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color): void;
+    pushSplat(center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color): void;
+    forEachSplat(callback: (index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color) => void): void;
+    ensureGenerate(maxSplats: number): boolean;
+    generateMapping(splatCounts: number[]): {
+        maxSplats: number;
+        mapping: {
+            base: number;
+            count: number;
+        }[];
+    };
+    getTexture(): THREE.DataArrayTexture;
+    private maybeUpdateSource;
+    private static emptySource;
+    static getEmpty(): THREE.DataArrayTexture;
+    prepareProgramMaterial(generator: GsplatGenerator): {
+        program: DynoProgram;
+        material: THREE.RawShaderMaterial;
+    };
+    private saveRenderState;
+    private resetRenderState;
+    generate({ generator, base, count, renderer, }: {
+        generator: GsplatGenerator;
+        base: number;
+        count: number;
+        renderer: THREE.WebGLRenderer;
+    }): {
+        nextBase: number;
+    };
+    static programTemplate: DynoProgramTemplate | null;
+    static generatorProgram: Map<GsplatGenerator, DynoProgram>;
+    static geometry: THREE.PlaneGeometry;
+    static mesh: THREE.Mesh<THREE.PlaneGeometry, THREE.RawShaderMaterial, THREE.Object3DEventMap>;
+    static scene: THREE.Scene;
+    static camera: THREE.Camera;
+}
+export declare const dynoPackedSplats: (packedSplats?: PackedSplats) => DynoPackedSplats;
+export declare class DynoPackedSplats extends DynoUniform<typeof TPackedSplats, "packedSplats", {
+    texture: THREE.DataArrayTexture;
+    numSplats: number;
+}> {
+    packedSplats?: PackedSplats;
+    constructor({ packedSplats }?: {
+        packedSplats?: PackedSplats;
+    });
+}

package/dist/types/Readback.d.ts

@@ -0,0 +1,50 @@
+import { Dyno } from './dyno';
+import { DynoProgram, DynoProgramTemplate } from './dyno/program';
+import * as THREE from "three";
+export type Rgba8Readback = Dyno<{
+    index: "int";
+}, {
+    rgba8: "vec4";
+}>;
+export type ReadbackBuffer = ArrayBuffer | Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array;
+export declare class Readback {
+    renderer?: THREE.WebGLRenderer;
+    target?: THREE.WebGLArrayRenderTarget;
+    capacity: number;
+    count: number;
+    constructor({ renderer }?: {
+        renderer?: THREE.WebGLRenderer;
+    });
+    dispose(): void;
+    ensureBuffer<B extends ReadbackBuffer>(count: number, buffer: B): B;
+    ensureCapacity(capacity: number): void;
+    prepareProgramMaterial(reader: Rgba8Readback): {
+        program: DynoProgram;
+        material: THREE.RawShaderMaterial;
+    };
+    private saveRenderState;
+    private resetRenderState;
+    private process;
+    private read;
+    render({ reader, count, renderer, }: {
+        reader: Rgba8Readback;
+        count: number;
+        renderer?: THREE.WebGLRenderer;
+    }): void;
+    readback<B extends ReadbackBuffer>({ readback, }: {
+        readback: B;
+    }): Promise<B>;
+    renderReadback<B extends ReadbackBuffer>({ reader, count, renderer, readback, }: {
+        reader: Rgba8Readback;
+        count: number;
+        renderer?: THREE.WebGLRenderer;
+        readback: B;
+    }): Promise<B>;
+    getTexture(): THREE.DataArrayTexture | undefined;
+    static programTemplate: DynoProgramTemplate | null;
+    static readbackProgram: Map<Rgba8Readback, DynoProgram>;
+    static geometry: THREE.PlaneGeometry;
+    static mesh: THREE.Mesh<THREE.PlaneGeometry, THREE.RawShaderMaterial, THREE.Object3DEventMap>;
+    static scene: THREE.Scene;
+    static camera: THREE.Camera;
+}

package/dist/types/RgbaArray.d.ts

@@ -0,0 +1,44 @@
+import { PackedSplats } from './PackedSplats';
+import { Readback, Rgba8Readback } from './Readback';
+import { DynoUniform, DynoVal } from './dyno';
+import * as THREE from "three";
+export type RgbaArrayOptions = {
+    capacity?: number;
+    array?: Uint8Array;
+    count?: number;
+};
+export declare class RgbaArray {
+    capacity: number;
+    count: number;
+    array: Uint8Array | null;
+    readback: Readback | null;
+    source: THREE.DataArrayTexture | null;
+    needsUpdate: boolean;
+    dyno: DynoUniform<typeof TRgbaArray, "rgbaArray">;
+    constructor(options?: RgbaArrayOptions);
+    dispose(): void;
+    ensureCapacity(capacity: number): Uint8Array;
+    getTexture(): THREE.DataArrayTexture;
+    private maybeUpdateSource;
+    render({ reader, count, renderer, }: {
+        reader: Rgba8Readback;
+        count: number;
+        renderer: THREE.WebGLRenderer;
+    }): void;
+    fromPackedSplats({ packedSplats, base, count, renderer, }: {
+        packedSplats: PackedSplats;
+        base: number;
+        count: number;
+        renderer: THREE.WebGLRenderer;
+    }): this;
+    read(): Promise<Uint8Array>;
+    private static emptySource;
+    static getEmpty(): THREE.DataArrayTexture;
+    private static dynos;
+    private static makeDynos;
+}
+export declare const TRgbaArray: {
+    type: "RgbaArray";
+};
+export declare const defineRgbaArray: string;
+export declare function readRgbaArray(rgba: DynoVal<typeof TRgbaArray>, index: DynoVal<"int">): DynoVal<"vec4">;

package/dist/types/SplatAccumulator.d.ts

@@ -0,0 +1,27 @@
+import { PackedSplats } from './PackedSplats';
+import { GsplatGenerator, SplatGenerator, SplatModifier } from './SplatGenerator';
+import * as THREE from "three";
+export type GeneratorMapping = {
+    node: SplatGenerator;
+    generator?: GsplatGenerator;
+    version: number;
+    base: number;
+    count: number;
+};
+export declare class SplatAccumulator {
+    splats: PackedSplats;
+    toWorld: THREE.Matrix4;
+    mapping: GeneratorMapping[];
+    refCount: number;
+    splatsVersion: number;
+    mappingVersion: number;
+    ensureGenerate(maxSplats: number): void;
+    generateSplats({ renderer, modifier, generators, forceUpdate, originToWorld, }: {
+        renderer: THREE.WebGLRenderer;
+        modifier: SplatModifier;
+        generators: GeneratorMapping[];
+        forceUpdate?: boolean;
+        originToWorld: THREE.Matrix4;
+    }): boolean;
+    hasCorrespondence(other: SplatAccumulator): boolean;
+}

package/dist/types/SplatEdit.d.ts

@@ -0,0 +1,94 @@
+import { DynoUniform, DynoVal, Gsplat } from './dyno';
+import * as THREE from "three";
+export declare enum SplatEditSdfType {
+    ALL = "all",
+    PLANE = "plane",
+    SPHERE = "sphere",
+    BOX = "box",
+    ELLIPSOID = "ellipsoid",
+    CYLINDER = "cylinder",
+    CAPSULE = "capsule",
+    INFINITE_CONE = "infinite_cone"
+}
+export declare enum SplatEditRgbaBlendMode {
+    MULTIPLY = "multiply",
+    SET_RGB = "set_rgb",
+    ADD_RGBA = "add_rgba"
+}
+export type SplatEditSdfOptions = {
+    type?: SplatEditSdfType;
+    invert?: boolean;
+    opacity?: number;
+    color?: THREE.Color;
+    displace?: THREE.Vector3;
+    radius?: number;
+};
+export declare class SplatEditSdf extends THREE.Object3D {
+    type: SplatEditSdfType;
+    invert: boolean;
+    opacity: number;
+    color: THREE.Color;
+    displace: THREE.Vector3;
+    radius: number;
+    constructor(options?: SplatEditSdfOptions);
+}
+export type SplatEditOptions = {
+    name?: string;
+    rgbaBlendMode?: SplatEditRgbaBlendMode;
+    sdfSmooth?: number;
+    softEdge?: number;
+    invert?: boolean;
+    sdfs?: SplatEditSdf[];
+};
+export declare class SplatEdit extends THREE.Object3D {
+    ordering: number;
+    rgbaBlendMode: SplatEditRgbaBlendMode;
+    sdfSmooth: number;
+    softEdge: number;
+    invert: boolean;
+    sdfs: SplatEditSdf[] | null;
+    static nextOrdering: number;
+    constructor(options?: SplatEditOptions);
+    addSdf(sdf: SplatEditSdf): void;
+    removeSdf(sdf: SplatEditSdf): void;
+}
+export declare class SplatEdits {
+    maxSdfs: number;
+    numSdfs: number;
+    sdfData: Uint32Array;
+    sdfFloatData: Float32Array;
+    sdfTexture: THREE.DataTexture;
+    dynoSdfArray: DynoUniform<typeof SdfArray, "sdfArray">;
+    maxEdits: number;
+    numEdits: number;
+    editData: Uint32Array;
+    editFloatData: Float32Array;
+    dynoNumEdits: DynoUniform<"int", "numEdits">;
+    dynoEdits: DynoUniform<"uvec4", "edits">;
+    constructor({ maxSdfs, maxEdits }: {
+        maxSdfs?: number;
+        maxEdits?: number;
+    });
+    private newSdfTexture;
+    private newEdits;
+    private ensureCapacity;
+    private updateEditData;
+    private updateEditFloatData;
+    private encodeEdit;
+    private updateSdfData;
+    private updateSdfFloatData;
+    private encodeSdf;
+    update(edits: {
+        edit: SplatEdit;
+        sdfs: SplatEditSdf[];
+    }[]): {
+        updated: boolean;
+        dynoUpdated: boolean;
+    };
+    modify(gsplat: DynoVal<typeof Gsplat>): DynoVal<typeof Gsplat>;
+}
+export declare const SdfArray: {
+    type: "SdfArray";
+};
+export declare const defineSdfArray: string;
+export declare const defineEdit: string;

package/dist/types/SplatGenerator.d.ts

@@ -0,0 +1,61 @@
+import { SplatEdit } from './SplatEdit';
+import { Dyno, DynoFloat, DynoVal, DynoVec3, DynoVec4, Gsplat } from './dyno';
+import * as THREE from "three";
+export type GsplatGenerator = Dyno<{
+    index: "int";
+}, {
+    gsplat: typeof Gsplat;
+}>;
+export type GsplatModifier = Dyno<{
+    gsplat: typeof Gsplat;
+}, {
+    gsplat: typeof Gsplat;
+}>;
+export declare class SplatModifier {
+    modifier: GsplatModifier;
+    cache: Map<GsplatGenerator, GsplatGenerator>;
+    constructor(modifier: GsplatModifier);
+    apply(generator: GsplatGenerator): GsplatGenerator;
+}
+export declare class SplatTransformer {
+    scale: DynoFloat;
+    rotate: DynoVec4<THREE.Quaternion>;
+    translate: DynoVec3<THREE.Vector3>;
+    constructor();
+    apply(position: DynoVal<"vec3">): DynoVal<"vec3">;
+    applyDir(dir: DynoVal<"vec3">): DynoVal<"vec3">;
+    applyGsplat(gsplat: DynoVal<typeof Gsplat>): DynoVal<typeof Gsplat>;
+    updateFromMatrix(transform: THREE.Matrix4): boolean;
+    update(object: THREE.Object3D): boolean;
+}
+export declare class SplatGenerator extends THREE.Object3D {
+    numSplats: number;
+    generator?: GsplatGenerator;
+    generatorError?: unknown;
+    frameUpdate?: ({ object, time, deltaTime, viewToWorld, globalEdits, }: {
+        object: SplatGenerator;
+        time: number;
+        deltaTime: number;
+        viewToWorld: THREE.Matrix4;
+        globalEdits: SplatEdit[];
+    }) => void;
+    version: number;
+    constructor({ numSplats, generator, construct, update, }: {
+        numSplats?: number;
+        generator?: GsplatGenerator;
+        construct?: (object: SplatGenerator) => {
+            generator?: GsplatGenerator;
+            numSplats?: number;
+            frameUpdate?: (object: SplatGenerator) => void;
+        };
+        update?: ({ object, time, deltaTime, viewToWorld, globalEdits, }: {
+            object: SplatGenerator;
+            time: number;
+            deltaTime: number;
+            viewToWorld: THREE.Matrix4;
+            globalEdits: SplatEdit[];
+        }) => void;
+    });
+    updateVersion(): void;
+    set needsUpdate(value: boolean);
+}

package/dist/types/SplatGeometry.d.ts

@@ -0,0 +1,7 @@
+import * as THREE from "three";
+export declare class SplatGeometry extends THREE.InstancedBufferGeometry {
+    ordering: Uint32Array;
+    attribute: THREE.InstancedBufferAttribute;
+    constructor(ordering: Uint32Array, activeSplats: number);
+    update(ordering: Uint32Array, activeSplats: number): void;
+}

package/dist/types/SplatLoader.d.ts

@@ -0,0 +1,80 @@
+import { FileLoader, Loader, LoadingManager } from 'three';
+import { PackedSplats } from './PackedSplats';
+import { SplatMesh } from './SplatMesh';
+export declare class SplatLoader extends Loader {
+    fileLoader: FileLoader;
+    fileType?: SplatFileType;
+    constructor(manager?: LoadingManager);
+    load(url: string, onLoad?: (decoded: PackedSplats) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
+    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<PackedSplats>;
+    parse(packedSplats: PackedSplats): SplatMesh;
+}
+export declare enum SplatFileType {
+    PLY = "ply",
+    SPZ = "spz",
+    SPLAT = "splat",
+    KSPLAT = "ksplat"
+}
+export declare function getSplatFileType(fileBytes: Uint8Array): SplatFileType | undefined;
+export declare function getFileExtension(pathOrUrl: string): string;
+export declare function getSplatFileTypeFromPath(pathOrUrl: string): SplatFileType | undefined;
+export declare function unpackSplats({ input, fileType, pathOrUrl, }: {
+    input: Uint8Array | ArrayBuffer;
+    fileType?: SplatFileType;
+    pathOrUrl?: string;
+}): Promise<{
+    packedArray: Uint32Array;
+    numSplats: number;
+    extra?: Record<string, unknown>;
+}>;
+export declare class SplatData {
+    numSplats: number;
+    maxSplats: number;
+    centers: Float32Array;
+    scales: Float32Array;
+    quaternions: Float32Array;
+    opacities: Float32Array;
+    colors: Float32Array;
+    sh1?: Float32Array;
+    sh2?: Float32Array;
+    sh3?: Float32Array;
+    constructor({ maxSplats }?: {
+        maxSplats?: number;
+    });
+    pushSplat(): number;
+    unpushSplat(index: number): void;
+    ensureCapacity(numSplats: number): void;
+    ensureIndex(index: number): void;
+    setCenter(index: number, x: number, y: number, z: number): void;
+    setScale(index: number, scaleX: number, scaleY: number, scaleZ: number): void;
+    setQuaternion(index: number, x: number, y: number, z: number, w: number): void;
+    setOpacity(index: number, opacity: number): void;
+    setColor(index: number, r: number, g: number, b: number): void;
+    setSh1(index: number, sh1: Float32Array): void;
+    setSh2(index: number, sh2: Float32Array): void;
+    setSh3(index: number, sh3: Float32Array): void;
+}
+export declare function transcodeSpz(input: TranscodeSpzInput): Promise<{
+    input: TranscodeSpzInput;
+    fileBytes: Uint8Array;
+}>;
+export type FileInput = {
+    fileBytes: Uint8Array;
+    fileType?: SplatFileType;
+    pathOrUrl?: string;
+    transform?: {
+        translate?: number[];
+        quaternion?: number[];
+        scale?: number;
+    };
+};
+export type TranscodeSpzInput = {
+    inputs: FileInput[];
+    maxSh?: number;
+    clipXyz?: {
+        min: number[];
+        max: number[];
+    };
+    fractionalBits?: number;
+    opacityThreshold?: number;
+};