@kingsy/viewer 2.25.7

package/dist/modules/pipeline/Passes/GPass.d.ts

@@ -0,0 +1,88 @@
+import { Camera, Material, OrthographicCamera, PerspectiveCamera, Plane, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { ObjectLayers } from '../../../IViewer.js';
+export declare enum ObjectVisibility {
+    OPAQUE = "opaque",
+    TRANSPARENT = "transparent",
+    DEPTH = "depth",
+    STENCIL = "stencil"
+}
+export declare enum ClearFlags {
+    COLOR = 256,
+    DEPTH = 1024,
+    STENCIL = 16384
+}
+export interface PassOptions {
+}
+export interface GPass {
+    get displayName(): string;
+    set outputTarget(value: WebGLRenderTarget);
+    get outputTarget(): WebGLRenderTarget | null;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    set options(value: PassOptions);
+    get visibility(): ObjectVisibility | null;
+    get overrideMaterial(): Material | null;
+    get overrideBatchMaterial(): Material | null;
+    get jitter(): boolean;
+    get clearColor(): number | undefined;
+    get clearAlpha(): number | undefined;
+    get clearFlags(): number | undefined;
+    setSize?(width: number, height: number): void;
+    onBeforeRender?: () => void;
+    onAferRender?: () => void;
+    update?(camera: PerspectiveCamera | OrthographicCamera | null): void;
+    render?(renderer: WebGLRenderer, camera?: PerspectiveCamera | OrthographicCamera | null, scene?: Scene): boolean;
+    setClearColor(color: number, alpha: number): void;
+    setClearFlags(flags: number): void;
+    setClippingPlanes?(planes: Plane[]): void;
+    setLayers?(layers: ObjectLayers[]): void;
+    setVisibility?(objectVisibility: ObjectVisibility): void;
+    setJitter(value: boolean): void;
+}
+export declare abstract class BaseGPass implements GPass {
+    protected _enabled: boolean;
+    protected layers: ObjectLayers[] | null;
+    protected _enabledLayers: ObjectLayers[];
+    protected _objectVisibility: ObjectVisibility | null;
+    protected _jitter: boolean;
+    protected _options: PassOptions;
+    protected _clearColor: number | undefined;
+    protected _clearAlpha: number | undefined;
+    protected _clearFlags: number | undefined;
+    protected _outputTarget: WebGLRenderTarget | null;
+    onBeforeRender: (() => void) | undefined;
+    onAfterRender: (() => void) | undefined;
+    get enabledLayers(): ObjectLayers[];
+    get displayName(): string;
+    get outputTarget(): WebGLRenderTarget | null;
+    set outputTarget(value: WebGLRenderTarget | null);
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    set options(value: PassOptions);
+    get visibility(): ObjectVisibility | null;
+    get overrideMaterial(): Material | null;
+    get overrideBatchMaterial(): Material | null;
+    get jitter(): boolean;
+    get clearColor(): number | undefined;
+    get clearAlpha(): number | undefined;
+    get clearFlags(): number | undefined;
+    setClearColor(color: number, alpha: number): void;
+    setClearFlags(flags: number): void;
+    setLayers(layers: ObjectLayers[]): void;
+    enableLayer(layer: ObjectLayers, value: boolean): void;
+    setVisibility(objectVisibility: ObjectVisibility | null): void;
+    setJitter(value: boolean): void;
+    protected applyLayers(camera: Camera | null): void;
+    protected clear(renderer: WebGLRenderer): void;
+    abstract render(renderer: WebGLRenderer, camera?: PerspectiveCamera | OrthographicCamera | null, scene?: Scene): boolean;
+    setSize(width: number, height: number): void;
+}
+export declare abstract class ProgressiveGPass extends BaseGPass {
+    protected _frameIndex: number;
+    protected _accumulationFrames: number;
+    get frameIndex(): number;
+    set frameIndex(value: number);
+    get accumulationFrames(): number;
+    set accumulationFrames(value: number);
+    render(renderer: WebGLRenderer, camera?: PerspectiveCamera | OrthographicCamera | null, scene?: Scene): boolean;
+}

package/dist/modules/pipeline/Passes/GeometryPass.d.ts

@@ -0,0 +1,7 @@
+import { OrthographicCamera, PerspectiveCamera, Plane, Scene, WebGLRenderer } from 'three';
+import { BaseGPass } from './GPass.js';
+export declare class GeometryPass extends BaseGPass {
+    get displayName(): string;
+    setClippingPlanes(planes: Plane[]): void;
+    render(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera | null, scene?: Scene): boolean;
+}

package/dist/modules/pipeline/Passes/NormalsPass.d.ts

@@ -0,0 +1,8 @@
+import { Material } from 'three';
+import { GeometryPass } from './GeometryPass.js';
+export declare class NormalsPass extends GeometryPass {
+    private normalsMaterial;
+    get displayName(): string;
+    get overrideMaterial(): Material;
+    constructor();
+}

package/dist/modules/pipeline/Passes/OutputPass.d.ts

@@ -0,0 +1,23 @@
+import { ShaderMaterial, Texture, WebGLRenderer } from 'three';
+import { BaseGPass, PassOptions } from './GPass.js';
+export declare enum InputType {
+    Color = 0,
+    PackedDepth = 1,
+    Normals = 2,
+    Passthrough = 3
+}
+export interface OutputPassOptions extends PassOptions {
+    inputType?: InputType;
+}
+export declare const DefaultOutputPassOptions: Required<OutputPassOptions>;
+export declare class OutputPass extends BaseGPass {
+    private fsQuad;
+    materialCopy: ShaderMaterial;
+    _options: Required<OutputPassOptions>;
+    set options(value: OutputPassOptions);
+    constructor();
+    protected setInputType(type: InputType): void;
+    setTexture(uName: string, texture: Texture | undefined): void;
+    get displayName(): string;
+    render(renderer: WebGLRenderer): boolean;
+}

package/dist/modules/pipeline/Passes/ProgressiveAOPass.d.ts

@@ -0,0 +1,30 @@
+import { OrthographicCamera, PerspectiveCamera, Texture, WebGLRenderer } from 'three';
+import { PassOptions, ProgressiveGPass } from './GPass.js';
+/**
+ * SAO implementation inspired from bhouston previous SAO work
+ */
+export interface ProgressiveAOPassOptions extends PassOptions {
+    intensity?: number;
+    kernelRadius?: number;
+    kernelSize?: number;
+    bias?: number;
+}
+export declare const DefaultProgressiveAOPassOptions: Required<ProgressiveAOPassOptions>;
+export declare class ProgressiveAOPass extends ProgressiveGPass {
+    private generationMaterial;
+    private accumulateMaterial;
+    private _generationBuffer;
+    _options: Required<ProgressiveAOPassOptions>;
+    private fsQuad;
+    private kernels;
+    private noiseTextures;
+    setTexture(uName: string, texture: Texture | undefined): void;
+    get displayName(): string;
+    set options(value: ProgressiveAOPassOptions);
+    constructor();
+    update(camera: PerspectiveCamera | OrthographicCamera): void;
+    render(renderer: WebGLRenderer): boolean;
+    setSize(width: number, height: number): void;
+    protected generateSampleKernel(frameIndex: number): void;
+    protected generateRandomKernelRotations(frameIndex: number): void;
+}

package/dist/modules/pipeline/Passes/ShadedPass.d.ts

@@ -0,0 +1,26 @@
+import { OrthographicCamera, PerspectiveCamera, Plane, Scene, WebGLRenderer } from 'three';
+import { BaseGPass } from './GPass.js';
+import { WorldTree } from '../../tree/WorldTree.js';
+import KingSyRenderer from '../../KingSyRenderer.js';
+import { MeshBatch } from '../../batching/MeshBatch.js';
+import { NodeRenderView } from '../../tree/NodeRenderView.js';
+import KingSyStandardColoredMaterial from '../../materials/KingSyStandardColoredMaterial.js';
+export declare class ShadedPass extends BaseGPass {
+    protected tree: WorldTree;
+    protected kingsyRenderer: KingSyRenderer;
+    protected materialMap: {
+        [batchID: string]: [
+            batch: MeshBatch,
+            colorMap: Map<number, Array<NodeRenderView>>,
+            material: KingSyStandardColoredMaterial
+        ];
+    };
+    constructor(tree: WorldTree, renderer: KingSyRenderer);
+    get displayName(): string;
+    setClippingPlanes(planes: Plane[]): void;
+    protected buildMaterials(): void;
+    applyColorIndices(): void;
+    protected overrideMaterials(): void;
+    protected restoreMaterials(): void;
+    render(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera | null, scene?: Scene): boolean;
+}

package/dist/modules/pipeline/Passes/ShadowcatcherPass.d.ts

@@ -0,0 +1,43 @@
+import { Box3, Plane, Scene, Texture, WebGLRenderer } from 'three';
+import KingSyDepthMaterial from '../../materials/KingSyDepthMaterial.js';
+import { type ShadowcatcherConfig } from '../../ShadowcatcherConfig.js';
+import { BaseGPass } from './GPass.js';
+export declare class ShadowcatcherPass extends BaseGPass {
+    private readonly levels;
+    private readonly debugCamera;
+    private renderTargets;
+    private tempTargets;
+    private camera;
+    private scene;
+    private _needsUpdate;
+    private fsQuad;
+    private blendMaterial;
+    private depthMaterial;
+    private vBlurMaterial;
+    private hBlurMaterial;
+    private blurStdDev;
+    private blurRadius;
+    private prevBlurStdDev;
+    private prevBlurRadius;
+    private cameraHelper;
+    onBeforeRender: (() => void) | undefined;
+    onAfterRender: (() => void) | undefined;
+    get displayName(): string;
+    get outputTexture(): Texture | null;
+    set needsUpdate(value: boolean);
+    get drawDepthMaterial(): KingSyDepthMaterial;
+    constructor();
+    update(scene: Scene): void;
+    render(_renderer: WebGLRenderer): boolean;
+    updateClippingPlanes(planes: Plane[]): void;
+    setOutputSize(width: number, height: number): void;
+    setWeights(weights: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): void;
+    updateCamera(planeBox: Box3, near: number, far: number): void;
+    updateConfig(config: ShadowcatcherConfig): void;
+    setSize(width: number, height: number): void;
+}

package/dist/modules/pipeline/Passes/StencilMaskPass.d.ts

@@ -0,0 +1,9 @@
+import { Material } from 'three';
+import { GeometryPass } from './GeometryPass.js';
+export declare class StencilMaskPass extends GeometryPass {
+    private stencilMaskMaterial;
+    constructor();
+    get displayName(): string;
+    get overrideMaterial(): Material;
+    setSize(width: number, height: number): void;
+}

package/dist/modules/pipeline/Passes/StencilPass.d.ts

@@ -0,0 +1,9 @@
+import { Material } from 'three';
+import { GeometryPass } from './GeometryPass.js';
+export declare class StencilPass extends GeometryPass {
+    private stencilMaterial;
+    constructor();
+    get displayName(): string;
+    get overrideMaterial(): Material;
+    setSize(width: number, height: number): void;
+}

package/dist/modules/pipeline/Passes/TAAPass.d.ts

@@ -0,0 +1,15 @@
+import { Texture, WebGLRenderer } from 'three';
+import { ProgressiveGPass } from './GPass.js';
+export declare class TAAPass extends ProgressiveGPass {
+    private inputTex;
+    private historyTarget;
+    private fsQuad;
+    outputToScreen: boolean;
+    private materialCopy;
+    private reprojectionMaterial;
+    constructor();
+    get displayName(): string;
+    set inputTexture(texture: Texture | undefined);
+    render(renderer: WebGLRenderer): boolean;
+    setSize(width: number, height: number): void;
+}

package/dist/modules/pipeline/Passes/ViewportPass.d.ts

@@ -0,0 +1,22 @@
+import { Material, OrthographicCamera, PerspectiveCamera, Scene, WebGLRenderer } from 'three';
+import { PassOptions } from './GPass.js';
+import KingSyViewportMaterial from '../../materials/KingSyViewportMaterial.js';
+import { Asset } from '../../../IViewer.js';
+import { GeometryPass } from './GeometryPass.js';
+export interface ViewportPassOptions extends PassOptions {
+    minIntensity?: number;
+    matcapTexture?: Asset | null;
+    opacity?: number;
+}
+export declare const DefaultViewportPassOptions: Required<ViewportPassOptions>;
+export declare class ViewportPass extends GeometryPass {
+    protected viewportMaterial: KingSyViewportMaterial;
+    protected pendingTexture: boolean;
+    _options: Required<ViewportPassOptions>;
+    get displayName(): string;
+    get overrideBatchMaterial(): Material;
+    set options(value: ViewportPassOptions);
+    constructor();
+    protected setMatcapTexture(asset: Asset | null): void;
+    render(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera | null, scene?: Scene): boolean;
+}

package/dist/modules/pipeline/Pipelines/ArcticViewPipeline.d.ts

@@ -0,0 +1,7 @@
+import KingSyRenderer from '../../KingSyRenderer.js';
+import { ProgressivePipeline } from './ProgressivePipeline.js';
+import { PipelineOptions } from './Pipeline.js';
+export declare class ArcticViewPipeline extends ProgressivePipeline {
+    protected accumulationFrameCount: number;
+    constructor(kingsyRenderer: KingSyRenderer, options?: PipelineOptions);
+}

package/dist/modules/pipeline/Pipelines/DefaultPipeline.d.ts

@@ -0,0 +1,6 @@
+import KingSyRenderer from '../../KingSyRenderer.js';
+import { ProgressivePipeline } from './ProgressivePipeline.js';
+import { PipelineOptions } from './Pipeline.js';
+export declare class DefaultPipeline extends ProgressivePipeline {
+    constructor(kingsyRenderer: KingSyRenderer, options?: PipelineOptions);
+}

package/dist/modules/pipeline/Pipelines/EdgesPipeline.d.ts

@@ -0,0 +1,28 @@
+import KingSyRenderer from '../../KingSyRenderer.js';
+import { EdgesPass } from '../Passes/EdgesPass.js';
+import { ProgressivePipeline } from './ProgressivePipeline.js';
+import { DepthNormalIdPass } from '../Passes/DepthNormalIdPass.js';
+import { Texture } from 'three';
+import { DepthPass } from '../Passes/DepthPass.js';
+import { BasePipelineOptions } from './Pipeline.js';
+export interface EdgesPipelineOptions extends BasePipelineOptions {
+    outlineThickness?: number;
+    outlineColor?: number;
+    outlineOpacity?: number;
+}
+export declare const DefaultEdgesPipelineOptions: {
+    outlineThickness: number;
+    outlineOpacity: number;
+    outlineColor: number;
+};
+export declare class EdgesPipeline extends ProgressivePipeline {
+    depthPass: DepthNormalIdPass | DepthPass;
+    depthPassDynamic: DepthNormalIdPass | DepthPass;
+    edgePass: EdgesPass;
+    edgePassDynamic: EdgesPass;
+    outputTexture?: Texture;
+    outputTextureDynamic?: Texture;
+    constructor(kingsyRenderer: KingSyRenderer, options?: EdgesPipelineOptions);
+    protected MRTPipeline(options: EdgesPipelineOptions): void;
+    protected SRTPipeline(options: EdgesPipelineOptions): void;
+}

package/dist/modules/pipeline/Pipelines/PenViewPipeline.d.ts

@@ -0,0 +1,6 @@
+import KingSyRenderer from '../../KingSyRenderer.js';
+import { ProgressivePipeline } from './ProgressivePipeline.js';
+import { PipelineOptions } from './Pipeline.js';
+export declare class PenViewPipeline extends ProgressivePipeline {
+    constructor(kingsyRenderer: KingSyRenderer, options?: PipelineOptions);
+}

package/dist/modules/pipeline/Pipelines/Pipeline.d.ts

@@ -0,0 +1,43 @@
+import { Matrix4, OrthographicCamera, PerspectiveCamera, Plane, Vector2, WebGLMultipleRenderTargets, WebGLRenderTarget, WebGLRenderTargetOptions } from 'three';
+import { GPass } from '../Passes/GPass.js';
+import KingSyRenderer from '../../KingSyRenderer.js';
+export interface BasePipelineOptions {
+}
+export interface PipelineOptions extends BasePipelineOptions {
+    edges?: boolean;
+}
+export declare const DefaultPipelineOptions: {
+    edges: boolean;
+};
+export declare abstract class Pipeline {
+    protected kingsyRenderer: KingSyRenderer;
+    protected _options: BasePipelineOptions;
+    protected passList: Array<GPass>;
+    protected drawingSize: Vector2;
+    protected frameProjection: Matrix4;
+    protected jitterIndex: number;
+    protected jitterOffsets: number[][];
+    get options(): BasePipelineOptions;
+    set options(value: BasePipelineOptions);
+    constructor(renderer: KingSyRenderer, options?: BasePipelineOptions);
+    get passes(): Array<GPass>;
+    onBeforePipelineRender(): void;
+    onAfterPipelineRender(): void;
+    getPass(name: string): GPass[];
+    setClippingPlanes(planes: Plane[]): void;
+    update(camera: PerspectiveCamera | OrthographicCamera): void;
+    reset(): void;
+    render(): boolean;
+    resize(width: number, height: number): void;
+    /**
+     * Generate a number in the Halton Sequence at a given index. This is
+     * shamelessly stolen from the pseudocode on the Wikipedia page
+     *
+     * @param base the base to use for the Halton Sequence
+     * @param index the index into the sequence
+     */
+    protected haltonNumber(base: number, index: number): number;
+    protected generateHaltonJiters(length: number): number[][];
+    static createRenderTarget(options?: WebGLRenderTargetOptions, width?: number, height?: number): WebGLRenderTarget;
+    static createMultipleRenderTarget(count: number, options?: WebGLRenderTargetOptions, width?: number, height?: number): WebGLMultipleRenderTargets;
+}

package/dist/modules/pipeline/Pipelines/ProgressivePipeline.d.ts

@@ -0,0 +1,24 @@
+import { OrthographicCamera, PerspectiveCamera, Plane } from 'three';
+import { GPass } from '../Passes/GPass.js';
+import { Pipeline } from './Pipeline.js';
+export declare abstract class ProgressivePipeline extends Pipeline {
+    protected accumulationFrameIndex: number;
+    protected accumulationFrameCount: number;
+    protected dynamicStage: Array<GPass>;
+    protected progressiveStage: Array<GPass>;
+    protected passthroughStage: Array<GPass>;
+    protected accumulating: boolean;
+    get passes(): Array<GPass>;
+    get dynamicPasses(): Array<GPass>;
+    get progressivePasses(): Array<GPass>;
+    get passthroughPasses(): Array<GPass>;
+    getPass(name: string): GPass[];
+    setClippingPlanes(planes: Plane[]): void;
+    update(camera: PerspectiveCamera | OrthographicCamera): void;
+    render(): boolean;
+    reset(): void;
+    resize(width: number, height: number): void;
+    onStationaryBegin(): void;
+    onStationaryEnd(): void;
+    onAccumulationComplete(): void;
+}

package/dist/modules/pipeline/Pipelines/ShadedViewPipeline.d.ts

@@ -0,0 +1,7 @@
+import KingSyRenderer from '../../KingSyRenderer.js';
+import { ProgressivePipeline } from './ProgressivePipeline.js';
+import { PipelineOptions } from './Pipeline.js';
+import { WorldTree } from '../../tree/WorldTree.js';
+export declare class ShadedViewPipeline extends ProgressivePipeline {
+    constructor(kingsyRenderer: KingSyRenderer, options: PipelineOptions | undefined, tree: WorldTree);
+}

package/dist/modules/pipeline/Pipelines/SolidViewPipeline.d.ts

@@ -0,0 +1,6 @@
+import KingSyRenderer from '../../KingSyRenderer.js';
+import { ProgressivePipeline } from './ProgressivePipeline.js';
+import { PipelineOptions } from './Pipeline.js';
+export declare class SolidViewPipeline extends ProgressivePipeline {
+    constructor(kingsyRenderer: KingSyRenderer, options?: PipelineOptions);
+}

package/dist/modules/pipeline/Pipelines/TAAPipeline.d.ts

@@ -0,0 +1,7 @@
+import KingSyRenderer from '../../KingSyRenderer.js';
+import { ProgressivePipeline } from './ProgressivePipeline.js';
+import { PipelineOptions } from './Pipeline.js';
+export declare class TAAPipeline extends ProgressivePipeline {
+    constructor(kingsyRenderer: KingSyRenderer, options?: PipelineOptions);
+    render(): boolean;
+}

package/dist/modules/queries/IntersectionQuerySolver.d.ts

@@ -0,0 +1,11 @@
+import KingSyRenderer from '../KingSyRenderer.js';
+import type { IntersectionQuery, IntersectionQueryResult } from './Query.js';
+export declare class IntersectionQuerySolver {
+    private vecBuff0;
+    private vecBuff1;
+    private renderer;
+    setContext(renderer: KingSyRenderer): void;
+    solve(query: IntersectionQuery): IntersectionQueryResult | null;
+    private solveOcclusion;
+    private solvePick;
+}

package/dist/modules/queries/PointQuerySolver.d.ts

@@ -0,0 +1,9 @@
+import KingSyRenderer from '../KingSyRenderer.js';
+import type { PointQuery, PointQueryResult } from './Query.js';
+export declare class PointQuerySolver {
+    private renderer;
+    setContext(renderer: KingSyRenderer): void;
+    solve(query: PointQuery): PointQueryResult | null;
+    private solveProjection;
+    private solveUnprojection;
+}

package/dist/modules/queries/Queries.d.ts

@@ -0,0 +1,9 @@
+import { IntersectionQuerySolver } from './IntersectionQuerySolver.js';
+import { PointQuerySolver } from './PointQuerySolver.js';
+import type { IntersectionQuery, PointQuery, Query } from './Query.js';
+export declare class Queries {
+    static DefaultPointQuerySolver: PointQuerySolver;
+    static DefaultIntersectionQuerySolver: IntersectionQuerySolver;
+    static isPointQuery(query: Query): query is PointQuery;
+    static isIntersectionQuery(query: Query): query is IntersectionQuery;
+}

package/dist/modules/queries/Query.d.ts

@@ -0,0 +1,51 @@
+export interface Query {
+    id?: string;
+    operation: string;
+}
+export type QueryResult = PointQueryResult | IntersectionQueryResult;
+export type QueryOperation = 'Project' | 'Unproject' | 'Occlusion' | 'Pick';
+export interface PointQuery extends Query {
+    point: {
+        x: number;
+        y: number;
+        z?: number;
+        w?: number;
+    };
+    operation: 'Project' | 'Unproject';
+}
+export interface IntersectionQuery extends Query {
+    point: {
+        x: number;
+        y: number;
+        z?: number;
+        w?: number;
+    };
+    tolerance?: number;
+    operation: 'Occlusion' | 'Pick';
+}
+export interface PointQueryResult {
+    x: number;
+    y: number;
+    z?: number;
+    w?: number;
+    inFrustum?: boolean;
+}
+export interface IntersectionQueryResult {
+    objects: Array<{
+        guid: string;
+        object?: Record<string, unknown>;
+        point: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }> | null;
+}
+export type QueryArgsResultMap = {
+    Project: PointQueryResult;
+    Unproject: PointQueryResult;
+    Occlusion: IntersectionQueryResult;
+    Pick: IntersectionQueryResult;
+} & {
+    [key: string]: unknown;
+};

package/dist/modules/three/stats.d.ts

@@ -0,0 +1,4 @@
+import StatsImport from 'three/examples/jsm/libs/stats.module.js';
+export type Stats = StatsImport.default;
+declare const Stats: () => Stats;
+export default Stats;

package/dist/modules/tree/NodeMap.d.ts

@@ -0,0 +1,20 @@
+import { type TreeNode } from './WorldTree.js';
+export declare class NodeMap {
+    static readonly COMPOUND_ID_CHAR = "~";
+    private all;
+    instances: {
+        [id: string]: {
+            [id: string]: TreeNode;
+        };
+    };
+    get nodeCount(): number;
+    constructor(subtreeRoot: TreeNode);
+    addNode(node: TreeNode): boolean;
+    removeNode(node: TreeNode): boolean;
+    getNodeById(id: string): TreeNode[] | null;
+    getSubtreeById(id: string): TreeNode;
+    hasId(id: string): boolean;
+    private registerInstance;
+    private registerNode;
+    purge(): void;
+}

package/dist/modules/tree/NodeRenderView.d.ts

@@ -0,0 +1,51 @@
+import { Box3 } from 'three';
+import { GeometryType } from '../batching/Batch.js';
+import { GeometryAttributes, type GeometryData } from '../converter/Geometry.js';
+import { MinimalMaterial, type DisplayStyle, type RenderMaterial } from '../materials/Materials.js';
+import { KingSyType } from '../loaders/GeometryConverter.js';
+export interface NodeRenderData {
+    id: string;
+    subtreeId: number;
+    kingsyType: KingSyType;
+    geometry: GeometryData;
+    renderMaterial: RenderMaterial | null;
+    displayStyle: DisplayStyle | null;
+    colorMaterial: MinimalMaterial | null;
+}
+export declare class NodeRenderView {
+    private _batchId;
+    private _batchIndexStart;
+    private _batchIndexCount;
+    private _batchVertexStart;
+    private _batchVertexEnd;
+    private readonly _renderData;
+    private _materialHash;
+    private _geometryType;
+    private _guid;
+    private _aabb;
+    /** TO DO: Not sure if we should store it */
+    get guid(): string;
+    get renderData(): NodeRenderData;
+    get renderMaterialHash(): number;
+    get hasGeometry(): ({
+        POSITION: number[];
+    } & Partial<Record<GeometryAttributes.COLOR | GeometryAttributes.NORMAL | GeometryAttributes.UV | GeometryAttributes.TANGENT | GeometryAttributes.INDEX, number[]>>) | null;
+    get hasMetadata(): import("../../IViewer.js").KingSyObject | undefined;
+    get kingsyType(): KingSyType;
+    get geometryType(): GeometryType;
+    get batchStart(): number;
+    get batchEnd(): number;
+    get batchCount(): number;
+    get batchId(): string;
+    get aabb(): Box3;
+    get transparent(): boolean;
+    get vertStart(): number;
+    get vertEnd(): number;
+    get needsSegmentConversion(): boolean;
+    get validGeometry(): boolean;
+    constructor(data: NodeRenderData);
+    setBatchData(id: string, start: number, count: number, vertStart?: number, vertEnd?: number): void;
+    computeAABB(): void;
+    private getGeometryType;
+    disposeGeometry(): void;
+}

package/dist/modules/tree/RenderTree.d.ts

@@ -0,0 +1,36 @@
+import { Matrix4 } from 'three';
+import { type TreeNode, WorldTree } from './WorldTree.js';
+import { NodeRenderView } from './NodeRenderView.js';
+import { GeometryConverter, KingSyType } from '../loaders/GeometryConverter.js';
+export declare class RenderTree {
+    private tree;
+    private root;
+    private cancel;
+    buildNodeTime: number;
+    applyTransformTime: number;
+    convertTime: number;
+    getNodeTime: number;
+    otherTime: number;
+    get id(): string;
+    get subtreeId(): number;
+    constructor(tree: WorldTree, subtreeRoot: TreeNode);
+    buildRenderTree(geometryConverter: GeometryConverter, callback?: () => void): Promise<boolean>;
+    private applyTransforms;
+    private buildRenderNode;
+    private getRenderMaterialNode;
+    private getDisplayStyleNode;
+    private getColorMaterialNode;
+    computeTransform(node: TreeNode): Matrix4;
+    getInstances(): {
+        [id: string]: Record<string, TreeNode>;
+    };
+    getRenderableRenderViews(...types: KingSyType[]): NodeRenderView[];
+    getRenderableNodes(...types: KingSyType[]): TreeNode[];
+    getRenderViewsForNode(node: TreeNode): NodeRenderView[];
+    getRenderViewNodesForNode(node: TreeNode): TreeNode[];
+    getRenderViewsForNodeId(id: string, subtreeId?: number): NodeRenderView[] | null;
+    getAtomicParent(node: TreeNode): TreeNode;
+    purge(): void;
+    /** TO DO: Need to purge only if currently building */
+    cancelBuild(): void;
+}