@sparkjsdev/spark
Version:
An advanced 3D Gaussian Splatting renderer for THREE.js
173 lines (172 loc) • 6.63 kB
TypeScript
import { ExtSplats } from './ExtSplats';
import { PackedSplats } from './PackedSplats';
import { RgbaArray, TRgbaArray } from './RgbaArray';
import { SplatEdit, SplatEdits } from './SplatEdit';
import { CovSplatModifier, CovSplatTransformer, FrameUpdateContext, GsplatModifier, SplatGenerator, SplatTransformer } from './SplatGenerator';
import { PagedSplats, SplatPager } from './SplatPager';
import { SplatSkinning } from './SplatSkinning';
import { SplatEncoding, SplatFileType } from './defines';
import { DynoBool, DynoFloat, DynoInt, DynoUsampler2D, DynoVal, DynoVec4, Gsplat } from './dyno';
import * as THREE from "three";
export type SplatMeshOptions = {
url?: string;
fileBytes?: Uint8Array | ArrayBuffer;
fileType?: SplatFileType;
fileName?: string;
stream?: ReadableStream;
streamLength?: number;
packedSplats?: PackedSplats;
splats?: SplatSource;
maxSplats?: number;
constructSplats?: (splats: PackedSplats) => Promise<void> | void;
onProgress?: (event: ProgressEvent) => void;
onLoad?: (mesh: SplatMesh) => Promise<void> | void;
editable?: boolean;
raycastable?: boolean;
minRaycastOpacity?: number;
onFrame?: ({ mesh, time, deltaTime, }: {
mesh: SplatMesh;
time: number;
deltaTime: number;
}) => void;
objectModifier?: GsplatModifier;
objectModifiers?: GsplatModifier[];
worldModifier?: GsplatModifier;
worldModifiers?: GsplatModifier[];
covObjectModifiers?: CovSplatModifier[];
covWorldModifiers?: CovSplatModifier[];
splatEncoding?: SplatEncoding;
extSplats?: boolean | ExtSplats;
covSplats?: boolean;
lod?: boolean | "quality";
lodAbove?: number;
nonLod?: boolean;
enableLod?: boolean;
lodScale?: number;
behindFoveate?: number;
coneFov0?: number;
coneFov?: number;
coneFoveate?: number;
paged?: boolean | PagedSplats | SplatPager;
};
export type SplatMeshContext = {
transform: SplatTransformer;
viewToWorld: SplatTransformer;
worldToView: SplatTransformer;
viewToObject: SplatTransformer;
covTransform: CovSplatTransformer;
covViewToWorld: CovSplatTransformer;
covWorldToView: CovSplatTransformer;
covViewToObject: CovSplatTransformer;
recolor: DynoVec4<THREE.Vector4>;
time: DynoFloat;
deltaTime: DynoFloat;
numSplats: DynoInt<string>;
splats: SplatSource;
enableLod: DynoBool<string>;
lodIndices: DynoUsampler2D<"lodIndices", THREE.DataTexture>;
};
export interface SplatSource {
prepareFetchSplat(): void;
dispose(): void;
getNumSplats(): number;
hasRgbDir(): boolean;
getNumSh(): number;
setMaxSh(maxSh: number): void;
fetchSplat({ index, viewOrigin, }: {
index: DynoVal<"int">;
viewOrigin?: DynoVal<"vec3">;
}): DynoVal<typeof Gsplat>;
forEachSplat(callback: (index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color) => void): void;
}
export declare class EmptySplatSource implements SplatSource {
fetchDyno: DynoVal<{
type: "Gsplat";
}>;
prepareFetchSplat(): void;
dispose(): void;
getNumSplats(): number;
hasRgbDir(): boolean;
getNumSh(): number;
setMaxSh(maxSh: number): void;
fetchSplat({ index }: {
index: DynoVal<"int">;
}): DynoVal<typeof Gsplat>;
forEachSplat(): void;
}
export declare class SplatMesh extends SplatGenerator {
initialized: Promise<SplatMesh>;
isInitialized: boolean;
packedSplats?: PackedSplats;
extSplats?: ExtSplats;
covSplats: boolean;
splats?: SplatSource;
lastSplats?: SplatSource;
paged?: PagedSplats;
recolor: THREE.Color;
opacity: number;
context: SplatMeshContext;
onFrame?: ({ mesh, time, deltaTime, }: {
mesh: SplatMesh;
time: number;
deltaTime: number;
}) => void;
generatorDirty: boolean;
objectModifiers?: GsplatModifier[];
worldModifiers?: GsplatModifier[];
covObjectModifiers?: CovSplatModifier[];
covWorldModifiers?: CovSplatModifier[];
enableViewToObject: boolean;
enableViewToWorld: boolean;
enableWorldToView: boolean;
skinning: SplatSkinning | null;
edits: SplatEdit[] | null;
editable: boolean;
raycastable: boolean;
minRaycastOpacity: number;
raycastIndices?: {
numSplats: number;
indices: Uint32Array;
};
rgbaDisplaceEdits: SplatEdits | null;
splatRgba: RgbaArray | null;
maxSh: number;
enableLod?: boolean;
lodScale: number;
behindFoveate?: number;
coneFov0?: number;
coneFov?: number;
coneFoveate?: number;
showLodPage?: number;
showLodPageDyno: DynoInt<string>;
constructor(options?: SplatMeshOptions);
asyncInitialize(options: SplatMeshOptions): Promise<void>;
static staticInitialized: Promise<void>;
static isStaticInitialized: boolean;
static dynoTime: DynoFloat<"value">;
static staticInitialize(): Promise<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;
dispose(): void;
getBoundingBox(centers_only?: boolean): THREE.Box3;
set objectModifier(modifier: GsplatModifier | undefined);
set worldModifier(modifier: GsplatModifier | undefined);
private constructGenerator;
constructCovGenerator(context: SplatMeshContext): void;
updateGenerator(): void;
update({ renderer, time, deltaTime, viewToWorld, camera, renderSize, globalEdits, lodIndices, }: FrameUpdateContext): void;
raycast(raycaster: THREE.Raycaster, intersects: {
distance: number;
point: THREE.Vector3;
object: THREE.Object3D;
}[]): void;
static raycastBuffer: Float32Array<ArrayBuffer>;
private appendRaycastBuffer;
createLodSplats({ rgbaArray, quality, }?: {
rgbaArray?: RgbaArray;
quality?: boolean;
}): Promise<void>;
}
export declare function maybeLookupIndex(lodIndices: DynoUsampler2D<"lodIndices", THREE.DataTexture>, index: DynoVal<"int">, numSplats: DynoVal<"int">, enableLod: DynoVal<"bool">, showLodPage: DynoVal<"int">): DynoVal<"int">;
export declare function maybeInjectSplatRgba(gsplat: DynoVal<typeof Gsplat>, rgba: DynoVal<typeof TRgbaArray>, index: DynoVal<"int">, enableLod: DynoVal<"bool">): DynoVal<typeof Gsplat>;
export declare const emptyLodIndices: THREE.DataTexture;