@idetik/core 0.23.2 → 0.23.4

package/dist/index.d.ts

@@ -411,25 +411,6 @@ declare abstract class Layer {
     getUniforms(): Record<string, unknown>;
 }
 
-declare class LayerManager {
-    private layers_;
-    private callbacks_;
-    private readonly context_;
-    constructor(context: IdetikContext);
-    partitionLayers(): {
-        opaque: Layer[];
-        transparent: Layer[];
-    };
-    add(layer: Layer): void;
-    remove(layer: Layer): void;
-    removeByIndex(index: number): void;
-    removeAll(): void;
-    get layers(): readonly Layer[];
-    private notifyLayersChanged;
-    addLayersChangeCallback(callback: () => void): () => void;
-    removeLayersChangeCallback(callback: () => void): void;
-}
-
 declare class OrthographicCamera extends Camera {
     private width_;
     private height_;
@@ -474,16 +455,21 @@ interface ViewportConfig {
 interface ViewportProps extends ViewportConfig {
     id: string;
     element: HTMLElement;
-    layerManager: LayerManager;
+    context: IdetikContext;
 }
 declare class Viewport {
     readonly id: string;
     readonly element: HTMLElement;
     readonly camera: Camera;
-    readonly layerManager: LayerManager;
     readonly events: EventDispatcher;
     cameraControls?: CameraControls;
+    private readonly context_;
+    private layers_;
     constructor(props: ViewportProps);
+    get layers(): readonly Layer[];
+    addLayer(layer: Layer): void;
+    removeLayer(layer: Layer): void;
+    removeAllLayers(): void;
     updateSize(): void;
     getBoxRelativeTo(canvas: HTMLCanvasElement): Box2;
     clientToClip(position: vec2, depth?: number): vec3;
@@ -491,14 +477,6 @@ declare class Viewport {
     private getBox;
     private updateAspectRatio;
 }
-declare function validateNewViewport(viewport: {
-    id: string;
-    element: HTMLElement;
-}, existingViewports: {
-    id: string;
-    element: HTMLElement;
-}[]): void;
-declare function parseViewportConfigs(viewportConfigs: ViewportConfig[], canvas: HTMLCanvasElement, context: IdetikContext): Viewport[];
 
 declare class ChunkStoreView {
     private readonly store_;
@@ -671,268 +649,6 @@ declare class Idetik {
     stop(): void;
 }
 
-declare class WebGLRenderer extends Renderer {
-    private readonly gl_;
-    private readonly programs_;
-    private readonly bindings_;
-    private readonly textures_;
-    private readonly state_;
-    private renderedObjectsPerFrame_;
-    private currentViewportSize_;
-    constructor(canvas: HTMLCanvasElement);
-    render(viewport: Viewport): void;
-    private initStencil;
-    private renderLayer;
-    protected renderObject(layer: Layer, objectIndex: number, camera: Camera): void;
-    private drawGeometry;
-    private glGetPrimitive;
-    protected resize(width: number, height: number): void;
-    protected clear(): void;
-}
-
-type PerspectiveCameraOptions = {
-    fov?: number;
-    aspectRatio?: number;
-    near?: number;
-    far?: number;
-    position?: vec3;
-};
-declare class PerspectiveCamera extends Camera {
-    private fov_;
-    private aspectRatio_;
-    constructor(options?: PerspectiveCameraOptions);
-    setAspectRatio(aspectRatio: number): void;
-    get type(): CameraType;
-    get fov(): number;
-    zoom(factor: number): void;
-    protected updateProjectionMatrix(): void;
-}
-
-type OrbitParams = {
-    radius?: number;
-    yaw?: number;
-    pitch?: number;
-    target?: vec3;
-    dampingFactor?: number;
-};
-declare class OrbitControls implements CameraControls {
-    private readonly camera_;
-    private readonly orbitVelocity_;
-    private readonly panVelocity_;
-    private readonly currPos_;
-    private readonly currCenter_;
-    private readonly dampingFactor_;
-    private currMouseButton_;
-    constructor(camera: PerspectiveCamera, params?: OrbitParams);
-    get isMoving(): boolean;
-    onEvent(event: EventContext): void;
-    onUpdate(dt: number): void;
-    private onPointerDown;
-    private onPointerMove;
-    private onWheel;
-    private onPointerEnd;
-    private orbit;
-    private pan;
-    private zoom;
-    private updateCamera;
-    private cutoffLowVelocity;
-}
-
-declare class AxesLayer extends Layer {
-    readonly type = "AxesLayer";
-    constructor(params: {
-        length: number;
-        width: number;
-    });
-    update(): void;
-}
-
-type ChannelProps = {
-    visible?: boolean;
-    color?: ColorLike;
-    contrastLimits?: [number, number];
-    opacity?: number;
-};
-/** Layer that exposes channel controls. */
-interface ChannelsEnabled {
-    channelProps: ChannelProps[] | undefined;
-    setChannelProps(channelProps: ChannelProps[]): void;
-    resetChannelProps(): void;
-    addChannelChangeCallback(callback: () => void): void;
-    removeChannelChangeCallback(callback: () => void): void;
-}
-
-interface PointPickingResult {
-    world: vec3;
-    value: number;
-}
-
-type ImageLayerProps = LayerOptions & {
-    source: ChunkSource;
-    sliceCoords: SliceCoordinates;
-    policy: ImageSourcePolicy;
-    channelProps?: ChannelProps[];
-    onPickValue?: (info: PointPickingResult) => void;
-};
-declare class ImageLayer extends Layer implements ChannelsEnabled {
-    readonly type = "ImageLayer";
-    private readonly source_;
-    private readonly sliceCoords_;
-    private readonly onPickValue_?;
-    private readonly visibleChunks_;
-    private readonly pool_;
-    private readonly initialChannelProps_?;
-    private readonly channelChangeCallbacks_;
-    private policy_;
-    private channelProps_?;
-    private chunkStoreView_?;
-    private pointerDownPos_;
-    private zPrevPointWorld_?;
-    private debugMode_;
-    private static readonly STALE_PRESENTATION_MS_;
-    private lastPresentationTimeStamp_?;
-    private lastPresentationTimeCoord_?;
-    private readonly wireframeColors_;
-    constructor({ source, sliceCoords, policy, channelProps, onPickValue, ...layerOptions }: ImageLayerProps);
-    onAttached(context: IdetikContext): Promise<void>;
-    onDetached(_context: IdetikContext): void;
-    update(context?: RenderContext): void;
-    private updateChunks;
-    hasMultipleLODs(): boolean;
-    get lastPresentationTimeCoord(): number | undefined;
-    private isPresentationStale;
-    private resliceIfZChanged;
-    onEvent(event: EventContext): void;
-    get chunkStoreView(): ChunkStoreView | undefined;
-    get sliceCoords(): SliceCoordinates;
-    get source(): ChunkSource;
-    get imageSourcePolicy(): Readonly<ImageSourcePolicy>;
-    set imageSourcePolicy(newPolicy: ImageSourcePolicy);
-    private slicePlane;
-    private getImageForChunk;
-    private getChannelPropsForChunk;
-    private createImage;
-    private getDataForImage;
-    private updateImageChunk;
-    getValueAtWorld(world: vec3): number | null;
-    private getValueFromChunk;
-    get debugMode(): boolean;
-    set debugMode(debug: boolean);
-    get channelProps(): ChannelProps[] | undefined;
-    setChannelProps(channelProps: ChannelProps[]): void;
-    resetChannelProps(): void;
-    addChannelChangeCallback(callback: () => void): void;
-    removeChannelChangeCallback(callback: () => void): void;
-    private releaseAndRemoveChunks;
-}
-
-type VolumeLayerProps = {
-    source: ChunkSource;
-    sliceCoords: SliceCoordinates;
-    policy: ImageSourcePolicy;
-    channelProps?: ChannelProps[];
-};
-declare class VolumeLayer extends Layer implements ChannelsEnabled {
-    readonly type = "VolumeLayer";
-    private readonly source_;
-    private readonly sliceCoords_;
-    private readonly currentVolumes_;
-    private readonly volumeToPoolKey_;
-    private readonly pool_;
-    private readonly initialChannelProps_?;
-    private readonly channelChangeCallbacks_;
-    private sourcePolicy_;
-    private chunkStoreView_?;
-    private channelProps_?;
-    private lastLoadedTime_;
-    private lastNumRenderedChannelChunks_;
-    private interactiveStepSizeScale_;
-    private debugShowWireframes_;
-    debugShowDegenerateRays: boolean;
-    relativeStepSize: number;
-    opacityMultiplier: number;
-    earlyTerminationAlpha: number;
-    get debugShowWireframes(): boolean;
-    set debugShowWireframes(value: boolean);
-    set sourcePolicy(newPolicy: ImageSourcePolicy);
-    setChannelProps(channelProps: ChannelProps[]): void;
-    get channelProps(): ChannelProps[] | undefined;
-    resetChannelProps(): void;
-    addChannelChangeCallback(callback: () => void): void;
-    removeChannelChangeCallback(callback: () => void): void;
-    constructor({ source, sliceCoords, policy, channelProps }: VolumeLayerProps);
-    private getOrCreateVolume;
-    onAttached(context: IdetikContext): Promise<void>;
-    onDetached(_context: IdetikContext): void;
-    private updateChunks;
-    private updateVolumeTransform;
-    private releaseAndRemoveVolume;
-    update(context?: RenderContext): void;
-    getUniforms(): Record<string, unknown>;
-}
-
-type LabelColorMapProps = {
-    lookupTable?: ReadonlyMap<number, ColorLike>;
-    cycle?: ColorLike[];
-};
-declare class LabelColorMap {
-    readonly lookupTable: ReadonlyMap<number, Color>;
-    readonly cycle: ReadonlyArray<Color>;
-    constructor(props?: LabelColorMapProps);
-}
-
-type LabelLayerProps = LayerOptions & {
-    source: ChunkSource;
-    sliceCoords: SliceCoordinates;
-    policy: ImageSourcePolicy;
-    colorMap?: LabelColorMapProps;
-    onPickValue?: (info: PointPickingResult) => void;
-    outlineSelected?: boolean;
-};
-declare class LabelLayer extends Layer {
-    readonly type = "LabelLayer";
-    private readonly source_;
-    private readonly sliceCoords_;
-    private readonly onPickValue_?;
-    private readonly outlineSelected_;
-    private readonly visibleChunks_;
-    private readonly pool_;
-    private colorMap_;
-    private selectedValue_;
-    private policy_;
-    private chunkStoreView_?;
-    private pointerDownPos_;
-    private zPrevPointWorld_?;
-    private static readonly STALE_PRESENTATION_MS_;
-    private lastPresentationTimeStamp_?;
-    private lastPresentationTimeCoord_?;
-    constructor({ source, sliceCoords, policy, colorMap, onPickValue, outlineSelected, ...layerOptions }: LabelLayerProps);
-    onAttached(context: IdetikContext): Promise<void>;
-    onDetached(_context: IdetikContext): void;
-    update(context?: RenderContext): void;
-    private updateChunks;
-    private isPresentationStale;
-    private resliceIfZChanged;
-    onEvent(event: EventContext): void;
-    get colorMap(): LabelColorMap;
-    setColorMap(colorMap: LabelColorMapProps): void;
-    setSelectedValue(value: number | null): void;
-    get sliceCoords(): SliceCoordinates;
-    get source(): ChunkSource;
-    get imageSourcePolicy(): Readonly<ImageSourcePolicy>;
-    set imageSourcePolicy(newPolicy: ImageSourcePolicy);
-    get chunkStoreView(): ChunkStoreView | undefined;
-    get lastPresentationTimeCoord(): number | undefined;
-    getValueAtWorld(world: vec3): number | null;
-    private getValueFromChunk;
-    private slicePlane;
-    private getLabelForChunk;
-    private createLabel;
-    private getDataForLabel;
-    private updateLabelChunk;
-    private releaseAndRemoveChunks;
-}
-
 /**The zarr.json attributes key*/
 declare const Image$1: z.ZodObject<{
     /**The versioned OME-Zarr Metadata namespace*/
@@ -1576,21 +1292,363 @@ declare class OmeZarrImageSource {
     static fromFileSystem(props: FileSystemOmeZarrImageSourceProps): OmeZarrImageSource;
 }
 
-declare class Plane {
-    normal: vec3;
-    signedDistance: number;
-    constructor(normal?: vec3, distance?: number);
-    set(normal: vec3, distance: number): void;
-    signedDistanceToPoint(point: vec3): number;
-    normalize(): void;
+declare class AxesLayer extends Layer {
+    readonly type = "AxesLayer";
+    constructor(params: {
+        length: number;
+        width: number;
+    });
+    update(): void;
 }
 
-declare class Spherical {
-    radius: number;
-    phi: number;
-    theta: number;
-    constructor(radius: number, phi: number, theta: number);
-    toVec3(): vec3;
+type ChannelProps = {
+    visible?: boolean;
+    color?: ColorLike;
+    contrastLimits?: [number, number];
+    opacity?: number;
+};
+/** Layer that exposes channel controls. */
+interface ChannelsEnabled {
+    channelProps: ChannelProps[] | undefined;
+    setChannelProps(channelProps: ChannelProps[]): void;
+    resetChannelProps(): void;
+    addChannelChangeCallback(callback: () => void): void;
+    removeChannelChangeCallback(callback: () => void): void;
+}
+
+interface PointPickingResult {
+    world: vec3;
+    value: number;
+}
+
+type ImageLayerProps = LayerOptions & {
+    source: ChunkSource;
+    sliceCoords: SliceCoordinates;
+    policy: ImageSourcePolicy;
+    channelProps?: ChannelProps[];
+    onPickValue?: (info: PointPickingResult) => void;
+};
+declare class ImageLayer extends Layer implements ChannelsEnabled {
+    readonly type = "ImageLayer";
+    private readonly source_;
+    private readonly sliceCoords_;
+    private readonly onPickValue_?;
+    private readonly visibleChunks_;
+    private readonly pool_;
+    private readonly initialChannelProps_?;
+    private readonly channelChangeCallbacks_;
+    private policy_;
+    private channelProps_?;
+    private chunkStoreView_?;
+    private pointerDownPos_;
+    private zPrevPointWorld_?;
+    private debugMode_;
+    private static readonly STALE_PRESENTATION_MS_;
+    private lastPresentationTimeStamp_?;
+    private lastPresentationTimeCoord_?;
+    private readonly wireframeColors_;
+    constructor({ source, sliceCoords, policy, channelProps, onPickValue, ...layerOptions }: ImageLayerProps);
+    onAttached(context: IdetikContext): Promise<void>;
+    onDetached(_context: IdetikContext): void;
+    update(context?: RenderContext): void;
+    private updateChunks;
+    hasMultipleLODs(): boolean;
+    get lastPresentationTimeCoord(): number | undefined;
+    private isPresentationStale;
+    private resliceIfZChanged;
+    onEvent(event: EventContext): void;
+    get chunkStoreView(): ChunkStoreView | undefined;
+    get sliceCoords(): SliceCoordinates;
+    get source(): ChunkSource;
+    get imageSourcePolicy(): Readonly<ImageSourcePolicy>;
+    set imageSourcePolicy(newPolicy: ImageSourcePolicy);
+    private slicePlane;
+    private getImageForChunk;
+    private getChannelPropsForChunk;
+    private createImage;
+    private getDataForImage;
+    private updateImageChunk;
+    getValueAtWorld(world: vec3): number | null;
+    private getValueFromChunk;
+    get debugMode(): boolean;
+    set debugMode(debug: boolean);
+    get channelProps(): ChannelProps[] | undefined;
+    setChannelProps(channelProps: ChannelProps[]): void;
+    resetChannelProps(): void;
+    addChannelChangeCallback(callback: () => void): void;
+    removeChannelChangeCallback(callback: () => void): void;
+    private releaseAndRemoveChunks;
+}
+
+type VolumeLayerProps = {
+    source: ChunkSource;
+    sliceCoords: SliceCoordinates;
+    policy: ImageSourcePolicy;
+    channelProps?: ChannelProps[];
+};
+declare class VolumeLayer extends Layer implements ChannelsEnabled {
+    readonly type = "VolumeLayer";
+    private readonly source_;
+    private readonly sliceCoords_;
+    private readonly currentVolumes_;
+    private readonly volumeToPoolKey_;
+    private readonly pool_;
+    private readonly initialChannelProps_?;
+    private readonly channelChangeCallbacks_;
+    private sourcePolicy_;
+    private chunkStoreView_?;
+    private channelProps_?;
+    private lastLoadedTime_;
+    private lastNumRenderedChannelChunks_;
+    private interactiveStepSizeScale_;
+    private debugShowWireframes_;
+    debugShowDegenerateRays: boolean;
+    relativeStepSize: number;
+    opacityMultiplier: number;
+    earlyTerminationAlpha: number;
+    get debugShowWireframes(): boolean;
+    set debugShowWireframes(value: boolean);
+    set sourcePolicy(newPolicy: ImageSourcePolicy);
+    setChannelProps(channelProps: ChannelProps[]): void;
+    get channelProps(): ChannelProps[] | undefined;
+    resetChannelProps(): void;
+    addChannelChangeCallback(callback: () => void): void;
+    removeChannelChangeCallback(callback: () => void): void;
+    constructor({ source, sliceCoords, policy, channelProps }: VolumeLayerProps);
+    private getOrCreateVolume;
+    onAttached(context: IdetikContext): Promise<void>;
+    onDetached(_context: IdetikContext): void;
+    private updateChunks;
+    private updateVolumeTransform;
+    private releaseAndRemoveVolume;
+    update(context?: RenderContext): void;
+    getUniforms(): Record<string, unknown>;
+}
+
+type LabelColorMapProps = {
+    lookupTable?: ReadonlyMap<number, ColorLike>;
+    cycle?: ColorLike[];
+};
+declare class LabelColorMap {
+    readonly lookupTable: ReadonlyMap<number, Color>;
+    readonly cycle: ReadonlyArray<Color>;
+    constructor(props?: LabelColorMapProps);
+}
+
+type LabelLayerProps = LayerOptions & {
+    source: ChunkSource;
+    sliceCoords: SliceCoordinates;
+    policy: ImageSourcePolicy;
+    colorMap?: LabelColorMapProps;
+    onPickValue?: (info: PointPickingResult) => void;
+    outlineSelected?: boolean;
+};
+declare class LabelLayer extends Layer {
+    readonly type = "LabelLayer";
+    private readonly source_;
+    private readonly sliceCoords_;
+    private readonly onPickValue_?;
+    private readonly outlineSelected_;
+    private readonly visibleChunks_;
+    private readonly pool_;
+    private colorMap_;
+    private selectedValue_;
+    private policy_;
+    private chunkStoreView_?;
+    private pointerDownPos_;
+    private zPrevPointWorld_?;
+    private static readonly STALE_PRESENTATION_MS_;
+    private lastPresentationTimeStamp_?;
+    private lastPresentationTimeCoord_?;
+    constructor({ source, sliceCoords, policy, colorMap, onPickValue, outlineSelected, ...layerOptions }: LabelLayerProps);
+    onAttached(context: IdetikContext): Promise<void>;
+    onDetached(_context: IdetikContext): void;
+    update(context?: RenderContext): void;
+    private updateChunks;
+    private isPresentationStale;
+    private resliceIfZChanged;
+    onEvent(event: EventContext): void;
+    get colorMap(): LabelColorMap;
+    setColorMap(colorMap: LabelColorMapProps): void;
+    setSelectedValue(value: number | null): void;
+    get sliceCoords(): SliceCoordinates;
+    get source(): ChunkSource;
+    get imageSourcePolicy(): Readonly<ImageSourcePolicy>;
+    set imageSourcePolicy(newPolicy: ImageSourcePolicy);
+    get chunkStoreView(): ChunkStoreView | undefined;
+    get lastPresentationTimeCoord(): number | undefined;
+    getValueAtWorld(world: vec3): number | null;
+    private getValueFromChunk;
+    private slicePlane;
+    private getLabelForChunk;
+    private createLabel;
+    private getDataForLabel;
+    private updateLabelChunk;
+    private releaseAndRemoveChunks;
+}
+
+type UniformValues = {
+    Color: vec3;
+    ImageSampler: number;
+    Opacity: number;
+    ValueOffset: number;
+    ValueScale: number;
+};
+declare class ImageRenderable extends RenderableObject {
+    private channels_;
+    constructor(width: number, height: number, texture: Texture, channels?: ChannelProps[]);
+    get type(): string;
+    setChannelProps(channels: ChannelProps[]): void;
+    setChannelProperty<K extends keyof ChannelProps>(channelIndex: number, property: K, value: Required<ChannelProps>[K]): void;
+    getUniforms(): UniformValues;
+}
+
+type LabelImageRenderableProps = {
+    width: number;
+    height: number;
+    imageData: Texture;
+    colorMap: LabelColorMap;
+    outlineSelected?: boolean;
+    selectedValue?: number | null;
+};
+declare class LabelImageRenderable extends RenderableObject {
+    private outlineSelected_;
+    private selectedValue_;
+    constructor(props: LabelImageRenderableProps);
+    get type(): string;
+    getUniforms(): {
+        ImageSampler: number;
+        ColorCycleSampler: number;
+        ColorLookupTableSampler: number;
+        u_outlineSelected: number;
+        u_selectedValue: number;
+    };
+    setColorMap(colorMap: LabelColorMap): void;
+    setSelectedValue(value: number | null): void;
+    private makeColorCycleTexture;
+    private makeColorLookupTableTexture;
+}
+
+declare class Texture2DArray extends Texture {
+    private data_;
+    private readonly width_;
+    private readonly height_;
+    private readonly depth_;
+    constructor(data: DataTextureTypedArray, width: number, height: number);
+    get type(): string;
+    set data(data: DataTextureTypedArray);
+    get data(): DataTextureTypedArray;
+    get width(): number;
+    get height(): number;
+    get depth(): number;
+    updateWithChunk(chunk: Chunk, data?: ChunkData): void;
+    static createWithChunk(chunk: Chunk, data?: ChunkData): Texture2DArray;
+}
+
+type PointProperties = {
+    position: vec3;
+    color: Color;
+    size: number;
+    markerIndex: number;
+};
+declare class Points extends RenderableObject {
+    private atlas_;
+    constructor(points: PointProperties[], markerAtlas: Texture2DArray);
+    get type(): string;
+}
+
+declare class ProjectedLineGeometry extends Geometry {
+    constructor(path: vec3[]);
+    private createVertices;
+    private createIndex;
+}
+
+type LineParameters = {
+    geometry: ProjectedLineGeometry;
+    color: ColorLike;
+    width: number;
+};
+declare class ProjectedLine extends RenderableObject {
+    private color_;
+    private width_;
+    constructor({ geometry, color, width }: LineParameters);
+    get type(): string;
+    get color(): Color;
+    set color(value: ColorLike);
+    get width(): number;
+    set width(value: number);
+    getUniforms(): {
+        LineColor: [number, number, number];
+        LineWidth: number;
+    };
+}
+
+declare class VolumeRenderable extends RenderableObject {
+    voxelScale: vec3;
+    private channels_;
+    private channelToTextureIndex_;
+    private loadedChannels_;
+    constructor();
+    get type(): string;
+    updateVolumeWithChunk(chunk: Chunk): void;
+    private addChannelTexture;
+    private updateChannelTexture;
+    clearLoadedChannels(): void;
+    getUniforms(): Record<string, number[] | number>;
+    /**
+     * Get an available texture for a channel. If desiredChannelIndex is provided, it will try to return the texture for that channel index. If that texture is not available, or no desiredChannelIndex is passed, return the first available channel texture. This is used to determine which texture to use when updating channel properties, since channel properties can be updated even if the channel's texture hasn't been loaded yet. If no textures are available, it returns null, which signals that default contrast limits should be used when validating the channel properties.
+     */
+    private getAvailableChannelTexture;
+    setChannelProps(channels: ChannelProps[]): void;
+    setChannelProperty<K extends keyof ChannelProps>(channelIndex: number, property: K, value: Required<ChannelProps>[K]): void;
+}
+
+type PerspectiveCameraOptions = {
+    fov?: number;
+    aspectRatio?: number;
+    near?: number;
+    far?: number;
+    position?: vec3;
+};
+declare class PerspectiveCamera extends Camera {
+    private fov_;
+    private aspectRatio_;
+    constructor(options?: PerspectiveCameraOptions);
+    setAspectRatio(aspectRatio: number): void;
+    get type(): CameraType;
+    get fov(): number;
+    zoom(factor: number): void;
+    protected updateProjectionMatrix(): void;
+}
+
+type OrbitParams = {
+    radius?: number;
+    yaw?: number;
+    pitch?: number;
+    target?: vec3;
+    dampingFactor?: number;
+};
+declare class OrbitControls implements CameraControls {
+    private readonly camera_;
+    private readonly orbitVelocity_;
+    private readonly panVelocity_;
+    private readonly currPos_;
+    private readonly currCenter_;
+    private readonly dampingFactor_;
+    private currMouseButton_;
+    constructor(camera: PerspectiveCamera, params?: OrbitParams);
+    get isMoving(): boolean;
+    onEvent(event: EventContext): void;
+    onUpdate(dt: number): void;
+    private onPointerDown;
+    private onPointerMove;
+    private onWheel;
+    private onPointerEnd;
+    private orbit;
+    private pan;
+    private zoom;
+    private updateCamera;
+    private cutoffLowVelocity;
 }
 
 /**JSON from OME-NGFF .zattrs*/
@@ -1795,49 +1853,5 @@ declare const Image: z.ZodObject<{
 }>;
 type Image = z.infer<typeof Image>;
 
-declare class Texture2DArray extends Texture {
-    private data_;
-    private readonly width_;
-    private readonly height_;
-    private readonly depth_;
-    constructor(data: DataTextureTypedArray, width: number, height: number);
-    get type(): string;
-    set data(data: DataTextureTypedArray);
-    get data(): DataTextureTypedArray;
-    get width(): number;
-    get height(): number;
-    get depth(): number;
-    updateWithChunk(chunk: Chunk, data?: ChunkData): void;
-    static createWithChunk(chunk: Chunk, data?: ChunkData): Texture2DArray;
-}
-
-type PointProperties = {
-    position: vec3;
-    color: Color;
-    size: number;
-    markerIndex: number;
-};
-declare class Points extends RenderableObject {
-    private atlas_;
-    constructor(points: PointProperties[], markerAtlas: Texture2DArray);
-    get type(): string;
-}
-
-declare class Texture3D extends Texture {
-    private data_;
-    private readonly width_;
-    private readonly height_;
-    private readonly depth_;
-    constructor(data: DataTextureTypedArray, width: number, height: number, depth: number);
-    set data(data: DataTextureTypedArray);
-    get type(): string;
-    get data(): DataTextureTypedArray;
-    get width(): number;
-    get height(): number;
-    get depth(): number;
-    updateWithChunk(chunk: Chunk): void;
-    static createWithChunk(chunk: Chunk): Texture3D;
-}
-
-export { AxesLayer, Box2, Box3, Color, EventContext, Frustum, Idetik, ImageLayer, LabelLayer, Layer, LayerManager, Image as OmeZarrImage, OmeZarrImageSource, OrbitControls, OrthographicCamera, PanZoomControls, PerspectiveCamera, Plane, Points, Spherical, Texture2DArray, Texture3D, Viewport, VolumeLayer, WebGLRenderer, createExplorationPolicy, createImageSourcePolicy, createNoPrefetchPolicy, createPlaybackPolicy, loadOmeZarrPlate, loadOmeZarrWell, loadOmeroChannels, loadOmeroDefaults, parseViewportConfigs, validateNewViewport };
-export type { CameraControls, ChannelProps, ChannelsEnabled, Chunk, ChunkLoader, ColorLike, ImageLayerProps, ImageSourcePolicy, ImageSourcePolicyConfig, LabelColorMapProps, LabelLayerProps, LayerState, OmeroChannel, OmeroMetadata, Overlay, PointPickingResult, PriorityCategory, QueueStats, SliceCoordinates, ViewportConfig };
+export { AxesLayer, Color, Idetik, ImageLayer, ImageRenderable, LabelColorMap, LabelImageRenderable, LabelLayer, Layer, Image as OmeZarrImage, OmeZarrImageSource, OrbitControls, OrthographicCamera, PanZoomControls, PerspectiveCamera, Points, ProjectedLine, Texture2DArray, VolumeLayer, VolumeRenderable, createExplorationPolicy, createImageSourcePolicy, createNoPrefetchPolicy, createPlaybackPolicy, loadOmeZarrPlate, loadOmeZarrWell, loadOmeroChannels, loadOmeroDefaults };
+export type { ChannelProps, ColorLike, LayerState, Overlay, SliceCoordinates };