@aics/vole-core 3.12.4

package/es/types/FileSaver.d.ts

@@ -0,0 +1,6 @@
+export default class FileSaver {
+    static save(blob: Blob, fname: string): void;
+    static saveString(s: string, fname: string): void;
+    static saveBinary(s: ArrayBuffer, fname: string): void;
+    static saveArrayBuffer(buffer: BlobPart, filename: string): void;
+}

package/es/types/FusedChannelData.d.ts

@@ -0,0 +1,26 @@
+import { DataTexture, WebGLRenderer, Texture } from "three";
+import Channel from "./Channel.js";
+import type { FuseChannel } from "./types.js";
+export default class FusedChannelData {
+    width: number;
+    height: number;
+    maskTexture: DataTexture;
+    private fuseRequested;
+    private channelsDataToFuse;
+    private fuseGeometry;
+    private fuseMaterialF;
+    private fuseMaterialUI;
+    private fuseMaterialI;
+    private fuseMaterialProps;
+    private fuseScene;
+    private quadCamera;
+    private fuseRenderTarget;
+    constructor(atlasX: number, atlasY: number);
+    private setupFuseMaterial;
+    getFusedTexture(): Texture;
+    cleanup(): void;
+    private getShader;
+    fuse(combination: FuseChannel[], channels: Channel[]): void;
+    gpuFuse(renderer: WebGLRenderer): void;
+    setChannelAsMask(idx: number, channel: Channel): boolean;
+}

package/es/types/Histogram.d.ts

@@ -0,0 +1,57 @@
+import type { TypedArray, NumberType } from "./types.js";
+/**
+ * Builds a histogram with 256 bins from a data array. Assume data is 8 bit single channel grayscale.
+ * @class
+ * @param {Array.<number>} data
+ */
+export default class Histogram {
+    private bins;
+    /** Min value in the original raw data. */
+    private min;
+    /** Max value in the original raw data. */
+    private max;
+    /** Size of each histogram bin in the scale of the original data. */
+    private binSize;
+    /** Index of the first bin (other than 0) with at least 1 value. */
+    private dataMinBin;
+    /** Index of the last bin (other than 0) with at least 1 value. */
+    private dataMaxBin;
+    private pixelCount;
+    maxBin: number;
+    constructor(data: TypedArray<NumberType>);
+    static findBin(dataValue: number, dataMin: number, binSize: number, numBins: number): number;
+    findBinOfValue(value: number): number;
+    /**
+     * Return the min data value
+     * @return {number}
+     */
+    getDataMin(): number;
+    /**
+     * Return the max data value
+     * @return {number}
+     */
+    getDataMax(): number;
+    /**
+     * Returns the first bin index with at least 1 value, other than the 0th bin.
+     * @return {number}
+     */
+    getMin(): number;
+    /**
+     * Returns the last bin index with at least 1 value, other than the 0th bin.
+     * @return {number}
+     */
+    getMax(): number;
+    getNumBins(): number;
+    getBin(i: number): number;
+    getBinRange(i: number): [number, number];
+    /**
+     * Find the bin that contains the percentage of pixels below it
+     * @return {number}
+     * @param {number} pct
+     */
+    findBinOfPercentile(pct: number): number;
+    findBestFitBins(): [number, number];
+    findAutoIJBins(): [number, number];
+    findAutoMinMax(): [number, number];
+    private static calculateHistogram;
+}

package/es/types/ImageInfo.d.ts

@@ -0,0 +1,87 @@
+import { type VolumeDims } from "./VolumeDims.js";
+import { Vector3, Vector2 } from "three";
+export type ImageInfo = Readonly<{
+    name: string;
+    /**
+     * XY dimensions of the texture atlas used by `RayMarchedAtlasVolume` and `Atlas2DSlice`, in number of z-slice
+     * tiles (not pixels). Chosen by the loader to lay out the 3D volume in the squarest possible 2D texture atlas.
+     */
+    atlasTileDims: [number, number];
+    /** Size of the currently loaded subregion, in pixels, in XYZ order */
+    subregionSize: [number, number, number];
+    /** Offset of the loaded subregion into the total volume, in pixels, in XYZ order */
+    subregionOffset: [number, number, number];
+    /** Number of channels in the image, accounting for convergence of multiple sources.
+     * Because of multiple sources, which is not accounted for in ImageInfo,
+     * that this could be different than the number of channels in the multiscaleLevelDims.
+     * NOTE Currently there is one ImageInfo per Volume, not per source.
+     */
+    combinedNumChannels: number;
+    /** The names of each channel */
+    channelNames: string[];
+    /** Optional overrides to default channel colors, in 0-255 range, RGB order */
+    channelColors?: [number, number, number][];
+    /** Dimensions of each scale level, at original size, from the first data source */
+    multiscaleLevelDims: VolumeDims[];
+    /** The scale level from which this image was loaded, between `0` and `numMultiscaleLevels-1` */
+    multiscaleLevel: number;
+    /**
+     * An *optional* transform which may be supplied by image metadata. It is *not* applied by
+     * default, but may be read and fed to `View3d` methods: `setVolumeTransform`,
+     * `setVolumeRotation`, `setVolumeScale`.
+     */
+    transform: {
+        /** Translation of the volume from the center of space, in volume voxels in XYZ order */
+        translation: [number, number, number];
+        /** Rotation of the volume in Euler angles, applied in XYZ order */
+        rotation: [number, number, number];
+        /** Scale of the volume relative to its size as derived from `multiscaleLevelDims`, in XYZ order */
+        scale: [number, number, number];
+    };
+    /** Arbitrary additional metadata not captured by other `ImageInfo` properties */
+    userData?: Record<string, unknown>;
+}>;
+export declare function defaultImageInfo(): ImageInfo;
+export declare class CImageInfo {
+    imageInfo: ImageInfo;
+    constructor(imageInfo?: ImageInfo);
+    get currentLevelDims(): VolumeDims;
+    /** Number of channels in the image */
+    get numChannels(): number;
+    /** XYZ size of the *original* (not downsampled) volume, in pixels */
+    get originalSize(): Vector3;
+    /** Size of the volume, in pixels */
+    get volumeSize(): Vector3;
+    /** Size of a single *original* (not downsampled) pixel, in spatial units */
+    get physicalPixelSize(): Vector3;
+    /** Symbol of physical spatial unit used by `physicalPixelSize` */
+    get spatialUnit(): string;
+    /** Number of timesteps in the time series, or 1 if the image is not a time series */
+    get times(): number;
+    /** Size of each timestep in temporal units */
+    get timeScale(): number;
+    /** Symbol of physical time unit used by `timeScale` */
+    get timeUnit(): string;
+    /** Number of scale levels available for this volume */
+    get numMultiscaleLevels(): number;
+    /** The names of each channel */
+    get channelNames(): string[];
+    /** Optional overrides to default channel colors, in 0-255 range */
+    get channelColors(): [number, number, number][] | undefined;
+    /** Size of the currently loaded subregion, in pixels */
+    get subregionSize(): Vector3;
+    /** Offset of the loaded subregion into the total volume, in pixels */
+    get subregionOffset(): Vector3;
+    get multiscaleLevel(): number;
+    /**
+     * XY dimensions of the texture atlas used by `RayMarchedAtlasVolume` and `Atlas2DSlice`, in number of z-slice
+     * tiles (not pixels). Chosen by the loader to lay out the 3D volume in the squarest possible 2D texture atlas.
+     */
+    get atlasTileDims(): Vector2;
+    get transform(): {
+        translation: Vector3;
+        rotation: Vector3;
+        scale: Vector3;
+    };
+}
+export declare function computeAtlasSize(imageInfo: ImageInfo): [number, number];

package/es/types/Light.d.ts

@@ -0,0 +1,27 @@
+import { Vector3, Matrix4 } from "three";
+export declare const AREA_LIGHT = 0;
+export declare const SKY_LIGHT = 1;
+export declare class Light {
+    mTheta: number;
+    mPhi: number;
+    mWidth: number;
+    mHeight: number;
+    mDistance: number;
+    mSkyRadius: number;
+    mP: Vector3;
+    mTarget: Vector3;
+    mArea: number;
+    mColor: Vector3;
+    mColorTop: Vector3;
+    mColorMiddle: Vector3;
+    mColorBottom: Vector3;
+    mT: number;
+    mN: Vector3;
+    mU: Vector3;
+    mV: Vector3;
+    mHalfWidth: number;
+    mHalfHeight: number;
+    private mAreaPdf;
+    constructor(type: number);
+    update(targetPoint: Vector3, cameraMatrix?: Matrix4): void;
+}

package/es/types/Lut.d.ts

@@ -0,0 +1,67 @@
+import Histogram from "./Histogram.js";
+export declare const LUT_ENTRIES = 256;
+export declare const LUT_ARRAY_LENGTH: number;
+/**
+ * @typedef {Object} ControlPoint Used for the TF (transfer function) editor GUI.
+ * Need to be converted to LUT for rendering.
+ * @property {number} x The X Coordinate: an intensity value, normalized to the 0-255 range
+ * @property {number} opacity The Opacity, from 0 to 1
+ * @property {Array.<number>} color The Color, 3 numbers from 0-255 for r,g,b
+ */
+export type ControlPoint = {
+    x: number;
+    opacity: number;
+    color: [number, number, number];
+};
+/**
+ * @typedef {Object} Lut Used for rendering. The start and end of the Lut represent the min and max of the data.
+ * @property {Array.<number>} lut LUT_ARRAY_LENGTH element lookup table as array
+ * (maps scalar intensity to a rgb color plus alpha, with each value from 0-255)
+ * @property {Array.<ControlPoint>} controlPoints
+ */
+export declare class Lut {
+    lut: Uint8Array;
+    controlPoints: ControlPoint[];
+    constructor();
+    /**
+     * Generate a piecewise linear lookup table that ramps up from 0 to 1 over the b to e domain.
+     * If e === b, then we use a step function with f(b) = 0 and f(b + 1) = 1
+     *  |
+     * 1|               +---------+-----
+     *  |              /
+     *  |             /
+     *  |            /
+     *  |           /
+     *  |          /
+     * 0+=========+---------------+-----
+     *  0         b    e         255
+     * @return {Lut}
+     * @param {number} b
+     * @param {number} e
+     */
+    createFromMinMax(b: number, e: number): Lut;
+    createFullRange(): Lut;
+    /**
+     * Generate a Window/level lookup table
+     * @return {Lut}
+     * @param {number} wnd in 0..1 range
+     * @param {number} lvl in 0..1 range
+     */
+    createFromWindowLevel(wnd: number, lvl: number): Lut;
+    createFromControlPoints(controlPoints: ControlPoint[]): Lut;
+    /**
+     * Generate an "equalized" lookup table
+     * @return {Lut}
+     */
+    createFromEqHistogram(histogram: Histogram): Lut;
+    /**
+     * Generate a lookup table with a different color per intensity value.
+     * This translates to a unique color per histogram bin with more than zero pixels.
+     * TODO THIS IS NOT THE EFFECT WE WANT.  Colorize should operate on actual data values, not histogram bins.
+     * @return {Lut}
+     */
+    createLabelColors(histogram: Histogram): Lut;
+    remapDomains(oldMin: number, oldMax: number, newMin: number, newMax: number): void;
+}
+export declare function remapLut(lut: Uint8Array, oldMin: number, oldMax: number, newMin: number, newMax: number): Uint8Array;
+export declare function remapControlPoints(controlPoints: ControlPoint[], oldMin: number, oldMax: number, newMin: number, newMax: number, nudgeEndPoints?: boolean): ControlPoint[];

package/es/types/MarchingCubes.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Port of http://webglsamples.org/blob/blob.html
+ */
+import { BufferGeometry, Material, Mesh } from "three";
+import type { TypedArray, NumberType } from "./types.js";
+declare class MarchingCubes extends Mesh {
+    isovalue: number;
+    enableUvs: boolean;
+    enableColors: boolean;
+    enableNormals: boolean;
+    dirty: boolean;
+    resolution: [number, number, number];
+    stepSizeX: number;
+    stepSizeY: number;
+    stepSizeZ: number;
+    sizeX: number;
+    sizeY: number;
+    sizeZ: number;
+    sizeXY: number;
+    sizeXYZ: number;
+    size3: number;
+    halfsizeX: number;
+    halfsizeY: number;
+    halfsizeZ: number;
+    deltaX: number;
+    deltaY: number;
+    deltaZ: number;
+    yd: number;
+    zd: number;
+    field: TypedArray<NumberType>;
+    normal_cache: Float32Array;
+    maxCount: number;
+    count: number;
+    hasPositions: boolean;
+    hasNormals: boolean;
+    hasColors: boolean;
+    hasUvs: boolean;
+    positionArray: Float32Array;
+    normalArray: Float32Array;
+    uvArray: Float32Array;
+    colorArray: Float32Array;
+    private init;
+    private begin;
+    private end;
+    private reset;
+    render: (renderCallback: (mc: MarchingCubes) => void) => void;
+    generateGeometry: () => BufferGeometry[] | undefined;
+    constructor(resolution: [number, number, number], material: Material, enableUvs: boolean, enableColors: boolean, enableNormals: boolean, volumeFieldRef: TypedArray<NumberType>);
+}
+declare const edgeTable: Int32Array;
+declare const triTable: Int32Array;
+export { MarchingCubes, edgeTable, triTable };
+export default MarchingCubes;

package/es/types/MeshVolume.d.ts

@@ -0,0 +1,40 @@
+import { BufferGeometry, Euler, Object3D, Vector3, Group, Material } from "three";
+import Volume from "./Volume.js";
+export default class MeshVolume {
+    private volume;
+    private meshRoot;
+    private meshPivot;
+    private meshrep;
+    private channelColors;
+    private channelOpacities;
+    private bounds;
+    private scale;
+    constructor(volume: Volume);
+    cleanup(): void;
+    setVisible(isVisible: boolean): void;
+    doRender(): void;
+    get3dObject(): Group;
+    setScale(scale: Vector3, position?: Vector3): void;
+    setFlipAxes(flipX: number, flipY: number, flipZ: number): void;
+    setTranslation(vec3xyz: Vector3): void;
+    setRotation(eulerXYZ: Euler): void;
+    setResolution(_x: number, _y: number): void;
+    setOrthoThickness(_value: number): void;
+    setAxisClip(axis: "x" | "y" | "z", minval: number, maxval: number, _isOrthoAxis: boolean): void;
+    updateMeshColors(channelColors: [number, number, number][]): void;
+    createMaterialForChannel(rgb: [number, number, number], alpha: number, _transp: boolean): Material;
+    createMeshForChannel(channelIndex: number, colorrgb: [number, number, number], isovalue: number, alpha: number, transp: boolean): Group;
+    updateIsovalue(channel: number, value: number): void;
+    getIsovalue(channel: number): number | undefined;
+    getOpacity(channel: number): number | undefined;
+    updateClipRegion(xmin: number, xmax: number, ymin: number, ymax: number, zmin: number, zmax: number): void;
+    updateClipFromBounds(): void;
+    updateOpacity(channel: number, value: number): void;
+    hasIsosurface(channel: number): boolean;
+    createIsosurface(channel: number, color: [number, number, number], value?: number, alpha?: number, transp?: boolean): void;
+    destroyIsosurface(channel: number): void;
+    saveChannelIsosurface(channelIndex: number, type: string, namePrefix: string): void;
+    exportSTL(input: Object3D, fname: string): void;
+    exportGLTF(input: Object3D, fname: string): void;
+    generateIsosurfaceGeometry(channelIndex: number, isovalue: number): BufferGeometry[];
+}

package/es/types/NaiveSurfaceNets.d.ts

@@ -0,0 +1,11 @@
+declare namespace _default {
+    export { SurfaceNets as surfaceNets };
+    export { ConstructTHREEGeometry as constructTHREEGeometry };
+}
+export default _default;
+declare function SurfaceNets(data: any, dims: any, isovalue: any): {
+    vertices: number[][];
+    faces: number[][];
+};
+declare function ConstructTHREEGeometry(surfaceNetResult: any): BufferGeometry[];
+import { BufferGeometry } from "three/src/core/BufferGeometry";

package/es/types/PathTracedVolume.d.ts

@@ -0,0 +1,65 @@
+import { Matrix4, Mesh, PerspectiveCamera, OrthographicCamera, WebGLRenderer } from "three";
+import Volume from "./Volume.js";
+import { type FuseChannel } from "./types.js";
+import { Light } from "./Light.js";
+import type { VolumeRenderImpl } from "./VolumeRenderImpl.js";
+import { VolumeRenderSettings, SettingsFlags } from "./VolumeRenderSettings.js";
+import Channel from "./Channel.js";
+export default class PathTracedVolume implements VolumeRenderImpl {
+    private settings;
+    private volume;
+    private viewChannels;
+    private volumeTexture;
+    private cameraIsMoving;
+    private sampleCounter;
+    private frameCounter;
+    private pathTracingUniforms;
+    private pathTracingRenderToBuffer;
+    private pathTracingRenderTarget;
+    private screenTextureRenderToBuffer;
+    private screenTextureRenderTarget;
+    private denoiseShaderUniforms;
+    private screenOutputShaderUniforms;
+    private screenOutputDenoiseMaterial;
+    private screenOutputMaterial;
+    private screenOutputGeometry;
+    private screenOutputMesh;
+    private gradientDelta;
+    private renderUpdateListener?;
+    /**
+     * Creates a new PathTracedVolume.
+     * @param volume The volume that this renderer should render data from.
+     * @param settings Optional settings object. If set, updates the renderer with
+     * the given settings. Otherwise, uses the default VolumeRenderSettings.
+     */
+    constructor(volume: Volume, settings?: VolumeRenderSettings);
+    cleanup(): void;
+    setRenderUpdateListener(callback?: (iteration: number) => void): void;
+    resetProgress(): void;
+    private getNormVolumeSize;
+    /**
+     * If the new settings have changed, applies all changes to this volume renderer.
+     * @param newSettings
+     * @returns
+     */
+    updateSettings(newSettings: VolumeRenderSettings, dirtyFlags?: number | SettingsFlags): void;
+    updateVolumeDimensions(): void;
+    doRender(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera): void;
+    get3dObject(): Mesh;
+    onStartControls(): void;
+    onChangeControls(): void;
+    onEndControls(): void;
+    viewpointMoved(): void;
+    updateActiveChannels(channelColors: FuseChannel[], channelData: Channel[]): void;
+    updateVolumeData4(): void;
+    updateLuts(channelColors: FuseChannel[], channelData: Channel[]): void;
+    updateMaterial(): void;
+    updateShadingMethod(brdf: number): void;
+    updateShowLights(showlights: number): void;
+    updateExposure(e: number): void;
+    updateCamera(fov: number, focalDistance: number, apertureSize: number): void;
+    updateLights(state: Light[]): void;
+    updateLightsSecondary(cameraMatrix?: Matrix4): void;
+    updateClipRegion(xmin: number, xmax: number, ymin: number, ymax: number, zmin: number, zmax: number): void;
+    setZSlice(_slice: number): boolean;
+}

package/es/types/RayMarchedAtlasVolume.d.ts

@@ -0,0 +1,41 @@
+import { DepthTexture, Group, OrthographicCamera, PerspectiveCamera, Texture, WebGLRenderer } from "three";
+import { Volume } from "./index.js";
+import Channel from "./Channel.js";
+import type { VolumeRenderImpl } from "./VolumeRenderImpl.js";
+import type { FuseChannel } from "./types.js";
+import { VolumeRenderSettings, SettingsFlags } from "./VolumeRenderSettings.js";
+export default class RayMarchedAtlasVolume implements VolumeRenderImpl {
+    private settings;
+    volume: Volume;
+    private geometry;
+    private geometryMesh;
+    private boxHelper;
+    private tickMarksMesh;
+    private geometryTransformNode;
+    private uniforms;
+    private channelData;
+    private emptyPositionTex;
+    /**
+     * Creates a new RayMarchedAtlasVolume.
+     * @param volume The volume that this renderer should render data from.
+     * @param settings Optional settings object. If set, updates the renderer with
+     * the given settings. Otherwise, uses the default VolumeRenderSettings.
+     */
+    constructor(volume: Volume, settings?: VolumeRenderSettings);
+    updateVolumeDimensions(): void;
+    viewpointMoved(): void;
+    updateSettings(newSettings: VolumeRenderSettings, dirtyFlags?: number | SettingsFlags): void;
+    /**
+     * Creates the geometry mesh and material for rendering the volume.
+     * @param uniforms object containing uniforms to pass to the shader material.
+     * @returns the new geometry and geometry mesh.
+     */
+    private createGeometry;
+    private createTickMarks;
+    cleanup(): void;
+    doRender(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture | Texture): void;
+    get3dObject(): Group;
+    private setUniform;
+    updateActiveChannels(channelcolors: FuseChannel[], channeldata: Channel[]): void;
+    setRenderUpdateListener(_listener?: ((iteration: number) => void) | undefined): void;
+}

package/es/types/RenderToBuffer.d.ts

@@ -0,0 +1,17 @@
+import { IUniform, Mesh, OrthographicCamera, PlaneGeometry, WebGLRenderer, Scene, ShaderMaterial, WebGLRenderTarget } from "three";
+/**
+ * Helper for render passes that just require a fragment shader: accepts a fragment shader and its
+ * uniforms, and handles the ceremony of rendering a fullscreen quad with a simple vertex shader.
+ */
+export default class RenderToBuffer {
+    scene: Scene;
+    geometry: PlaneGeometry;
+    material: ShaderMaterial;
+    mesh: Mesh;
+    camera: OrthographicCamera;
+    constructor(fragmentSrc: string, uniforms: {
+        [key: string]: IUniform;
+    });
+    /** Renders this pass to `target` using `renderer`, or to the canvas if no `target` is given. */
+    render(renderer: WebGLRenderer, target?: WebGLRenderTarget): void;
+}

package/es/types/ThreeJsPanel.d.ts

@@ -0,0 +1,107 @@
+import { Color, Event, EventListener, OrthographicCamera, PerspectiveCamera, WebGLRenderer, Scene, DepthTexture } from "three";
+import TrackballControls from "./TrackballControls.js";
+import { ViewportCorner } from "./types.js";
+export declare const VOLUME_LAYER = 0;
+export declare const MESH_LAYER = 1;
+export type CameraState = {
+    position: [number, number, number];
+    up: [number, number, number];
+    target: [number, number, number];
+    /** Full vertical FOV in degrees, from bottom to top of the view frustum. Defined only for perspective cameras. */
+    fov?: number;
+    /** The scale value for the orthographic camera controls; undefined for perspective cameras. */
+    orthoScale?: number;
+};
+export declare class ThreeJsPanel {
+    containerdiv: HTMLDivElement;
+    private canvas;
+    scene: Scene;
+    private meshRenderTarget;
+    private meshRenderToBuffer;
+    animateFuncs: ((renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture) => void)[];
+    private inRenderLoop;
+    private requestedRender;
+    hasWebGL2: boolean;
+    renderer: WebGLRenderer;
+    private timer;
+    private fov;
+    private perspectiveCamera;
+    private perspectiveControls;
+    private orthographicCameraX;
+    private orthoControlsX;
+    private orthographicCameraY;
+    private orthoControlsY;
+    private orthographicCameraZ;
+    private orthoControlsZ;
+    camera: PerspectiveCamera | OrthographicCamera;
+    private viewMode;
+    controls: TrackballControls;
+    private controlEndHandler?;
+    private controlChangeHandler?;
+    private controlStartHandler?;
+    showAxis: boolean;
+    private axisScale;
+    private axisOffset;
+    private axisHelperScene;
+    private axisHelperObject;
+    private axisCamera;
+    private scaleBarContainerElement;
+    private orthoScaleBarElement;
+    showOrthoScaleBar: boolean;
+    private perspectiveScaleBarElement;
+    showPerspectiveScaleBar: boolean;
+    private timestepIndicatorElement;
+    showTimestepIndicator: boolean;
+    private dataurlcallback?;
+    constructor(parentElement: HTMLElement | undefined, _useWebGL2: boolean);
+    updateCameraFocus(fov: number, _focalDistance: number, _apertureSize: number): void;
+    resetPerspectiveCamera(): void;
+    resetOrthographicCameraX(): void;
+    resetOrthographicCameraY(): void;
+    resetOrthographicCameraZ(): void;
+    requestCapture(dataurlcallback: (name: string) => void): void;
+    isVR(): boolean;
+    resetToPerspectiveCamera(): void;
+    resetCamera(): void;
+    setupAxisHelper(): void;
+    setAxisPosition(marginX: number, marginY: number, corner: ViewportCorner): void;
+    orthoScreenPixelsToPhysicalUnits(pixels: number, physicalUnitsPerWorldUnit: number): number;
+    setupIndicatorElements(): void;
+    updateOrthoScaleBar(scale: number, unit?: string): void;
+    updatePerspectiveScaleBar(length: number, unit?: string): void;
+    updateTimestepIndicator(progress: number, total: number, unit: string): void;
+    setPerspectiveScaleBarColor(color: [number, number, number]): void;
+    updateScaleBarVisibility(): void;
+    setShowOrthoScaleBar(visible: boolean): void;
+    setShowPerspectiveScaleBar(visible: boolean): void;
+    setShowTimestepIndicator(visible: boolean): void;
+    setIndicatorPosition(timestep: boolean, marginX: number, marginY: number, corner: ViewportCorner): void;
+    setAutoRotate(rotate: boolean): void;
+    getAutoRotate(): boolean;
+    replaceCamera(newCam: PerspectiveCamera | OrthographicCamera): void;
+    replaceControls(newControls: TrackballControls): void;
+    switchViewMode(mode: string): void;
+    getMeshDepthTexture(): DepthTexture;
+    resize(comp: HTMLElement | null, w?: number, h?: number, _ow?: number, _oh?: number, _eOpts?: unknown): void;
+    setClearColor(color: Color, alpha: number): void;
+    getWidth(): number;
+    getHeight(): number;
+    getCameraState(): CameraState;
+    /**
+     * Updates the camera's state, including the position, up vector, target position,
+     * scaling, and FOV. If values are missing from `state`, they will be left unchanged.
+     *
+     * @param state Partial `CameraState` object.
+     *
+     * If an OrthographicCamera is used, the camera's position will be constrained to match
+     * the `target` position along the current view mode.
+     */
+    setCameraState(state: Partial<CameraState>): void;
+    render(): void;
+    redraw(): void;
+    onAnimationLoop(): void;
+    startRenderLoop(): void;
+    stopRenderLoop(): void;
+    removeControlHandlers(): void;
+    setControlHandlers(onstart: EventListener<Event, "start", TrackballControls>, onchange: EventListener<Event, "change", TrackballControls>, onend: EventListener<Event, "end", TrackballControls>): void;
+}

package/es/types/Timing.d.ts

@@ -0,0 +1,11 @@
+export default class Timing {
+    private beginTime;
+    private prevTime;
+    private frames;
+    lastFrameMs: number;
+    private lastFPS;
+    constructor();
+    begin(): void;
+    end(): number;
+    update(): void;
+}

package/es/types/TrackballControls.d.ts

@@ -0,0 +1,51 @@
+export default TrackballControls;
+declare class TrackballControls extends EventDispatcher<import("three").Event> {
+    constructor(object: any, domElement: any);
+    object: any;
+    domElement: any;
+    enabled: boolean;
+    screen: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    length: number;
+    scale: number;
+    scale0: number;
+    aspect: number;
+    rotateSpeed: number;
+    zoomSpeed: number;
+    panSpeed: number;
+    noRotate: boolean;
+    noZoom: boolean;
+    noPan: boolean;
+    staticMoving: boolean;
+    dynamicDampingFactor: number;
+    minDistance: number;
+    maxDistance: number;
+    keys: string[];
+    mouseButtons: {
+        LEFT: MOUSE;
+        MIDDLE: MOUSE;
+        RIGHT: MOUSE;
+    };
+    autoRotate: boolean;
+    autoRotateSpeed: number;
+    target: Vector3;
+    target0: Vector3;
+    position0: any;
+    up0: any;
+    zoom0: any;
+    handleResize: () => void;
+    rotateCamera: (delta: any) => void;
+    zoomCamera: () => void;
+    panCamera: () => void;
+    checkDistances: () => void;
+    update: (delta: any) => void;
+    reset: () => void;
+    dispose: () => void;
+}
+import { EventDispatcher } from "three/src/core/EventDispatcher";
+import { MOUSE } from "three/src/constants";
+import { Vector3 } from "three/src/math/Vector3";