@kingsy/viewer 2.25.7

package/dist/modules/Assets.d.ts

@@ -0,0 +1,15 @@
+import { Texture, WebGLRenderer } from 'three';
+import { Font } from 'three/examples/jsm/loaders/FontLoader.js';
+import { type Asset } from '../IViewer.js';
+export declare class Assets {
+    private static _cache;
+    private static getLoader;
+    private static hdriToPMREM;
+    static getEnvironment(asset: Asset, renderer: WebGLRenderer): Promise<Texture>;
+    static getTexture(asset: Asset): Promise<Texture>;
+    static getFont(asset: Asset | string): Promise<Font>;
+    /** To be used wisely */
+    static getTextureData(asset: Asset): Promise<ImageData>;
+    static generateGradientRampTexture(fromColor: string, toColor: string, steps: number): void;
+    static generateDiscreetRampTexture(hexColors: number[]): Texture;
+}

package/dist/modules/EventEmitter.d.ts

@@ -0,0 +1,7 @@
+export default class EventEmitter {
+    _events: {};
+    on(name: any, listener: any): void;
+    removeListener(name: any, listenerToRemove: any): void;
+    emit(name: any, ...args: any[]): void;
+    dispose(): void;
+}

package/dist/modules/Helpers.d.ts

@@ -0,0 +1,3 @@
+import { Box3, Matrix4, Vector2 } from 'three';
+export declare function getRelativeOffset(referenceBox: Box3, offsetAmount?: number): number;
+export declare function makePerspectiveProjection(screenSize: Vector2, fov: number, near: number, far: number): Matrix4;

package/dist/modules/Intersections.d.ts

@@ -0,0 +1,20 @@
+import { Box3, Camera, Object3D, Plane, Ray, Scene, Vector2, Vector3 } from 'three';
+import { ExtendedIntersection, ExtendedMeshIntersection, KingSyRaycaster } from './objects/KingSyRaycaster.js';
+import { ObjectLayers } from '../IViewer.js';
+import { OBB } from 'three/examples/jsm/math/OBB.js';
+export declare class Intersections {
+    protected raycaster: KingSyRaycaster;
+    private boxBuffer;
+    private vec0Buffer;
+    private vec1Buffer;
+    private boundsBuffer;
+    constructor();
+    protected onObjectIntersection(obj: Object3D): void;
+    intersect(scene: Scene, camera: Camera, point: Vector2, castLayers: ObjectLayers.STREAM_CONTENT_MESH, nearest?: boolean, bounds?: Box3 | OBB, firstOnly?: boolean, tasOnly?: boolean): Array<ExtendedMeshIntersection> | null;
+    intersect(scene: Scene, camera: Camera, point: Vector2, castLayers?: Array<ObjectLayers>, nearest?: boolean, bounds?: Box3 | OBB, firstOnly?: boolean, tasOnly?: boolean): Array<ExtendedIntersection> | null;
+    intersectRay(scene: Scene, camera: Camera, ray: Ray, castLayers: ObjectLayers.STREAM_CONTENT_MESH, nearest?: boolean, bounds?: Box3 | OBB, firstOnly?: boolean, tasOnly?: boolean): Array<ExtendedMeshIntersection> | null;
+    intersectRay(scene: Scene, camera: Camera, ray: Ray, castLayers?: Array<ObjectLayers>, nearest?: boolean, bounds?: Box3 | OBB, firstOnly?: boolean, tasOnly?: boolean): Array<ExtendedIntersection> | null;
+    private setRaycasterLayers;
+    private intersectInternal;
+    static aabbPlanePoints: (plane: Plane, aabb: Box3) => Vector3[];
+}

package/dist/modules/KingSyRenderer.d.ts

@@ -0,0 +1,168 @@
+import { Box3, DirectionalLight, Group, Material, Object3D, Plane, Scene, Sphere, Texture, Vector3, PerspectiveCamera, OrthographicCamera } from 'three';
+import { type Batch } from './batching/Batch.js';
+import Batcher from './batching/Batcher.js';
+import Input from './input/Input.js';
+import { Intersections } from './Intersections.js';
+import { NodeRenderView } from './tree/NodeRenderView.js';
+import { Viewer } from './Viewer.js';
+import { WorldTree, type TreeNode } from './tree/WorldTree.js';
+import { ObjectLayers, type SunLightConfiguration } from '../IViewer.js';
+import { Shadowcatcher } from './Shadowcatcher.js';
+import { type ExtendedIntersection } from './objects/KingSyRaycaster.js';
+import { BatchObject } from './batching/BatchObject.js';
+import { type KingSyCamera } from './objects/KingSyCamera.js';
+import { type RenderMaterial, type DisplayStyle, type FilterMaterial } from './materials/Materials.js';
+import { type MaterialOptions } from './materials/MaterialOptions.js';
+import { KingSyWebGLRenderer } from './objects/KingSyWebGLRenderer.js';
+import { RenderTree } from './tree/RenderTree.js';
+import { Pipeline } from './pipeline/Pipelines/Pipeline.js';
+import { OBB } from 'three/examples/jsm/math/OBB.js';
+import '../type-augmentations/three-extensions.js';
+export declare class RenderingStats {
+    private renderTimeAcc;
+    private renderTimeSamples;
+    private readonly renderTimeMaxSamples;
+    private renderTimeStart;
+    renderTime: number;
+    objects: number;
+    batchCount: number;
+    drawCalls: number;
+    trisCount: number;
+    vertCount: number;
+    batchDetails: Array<{
+        drawCalls: number;
+        minDrawCalls: number;
+        tris: number;
+        verts: number;
+    }>;
+    frameStart(): void;
+    frameEnd(): void;
+}
+export default class KingSyRenderer {
+    protected readonly SHOW_HELPERS = false;
+    protected readonly IGNORE_ZERO_OPACITY_OBJECTS = true;
+    SHOW_BVH: boolean;
+    protected _renderer: KingSyWebGLRenderer;
+    protected _renderinStats: RenderingStats;
+    protected _scene: Scene;
+    protected _needsRender: boolean;
+    protected _intersections: Intersections;
+    protected _shadowcatcher: Shadowcatcher;
+    protected _kingsyCamera: KingSyCamera | null;
+    protected container: HTMLElement;
+    protected rootGroup: Group;
+    protected _pipeline: Pipeline;
+    protected sun: DirectionalLight;
+    protected sunConfiguration: SunLightConfiguration;
+    protected sunTarget: Object3D;
+    protected tree: WorldTree;
+    protected cancel: {
+        [subtreeId: string]: boolean;
+    };
+    protected _clippingPlanes: Plane[];
+    protected _clippingVolume: OBB;
+    protected _renderOverride: (() => void) | null;
+    viewer: Viewer;
+    batcher: Batcher;
+    input: Input;
+    /********************************
+     * Renderer and rendering flags */
+    get renderer(): KingSyWebGLRenderer;
+    set needsRender(value: boolean);
+    set shadowMapNeedsUpdate(value: boolean);
+    /**********************
+     * Bounds and volumes */
+    get sceneBox(): Box3;
+    get sceneSphere(): Sphere;
+    get sceneCenter(): Vector3;
+    get clippingVolume(): OBB;
+    set clippingVolume(box: Box3 | OBB);
+    /*****************
+     * Clipping planes */
+    get clippingPlanes(): Plane[];
+    set clippingPlanes(value: Plane[]);
+    /****************
+     * Common Objects */
+    get allObjects(): Object3D;
+    get scene(): Scene;
+    /********
+     * Lights */
+    get sunLight(): DirectionalLight;
+    set indirectIBL(texture: Texture);
+    set indirectIBLIntensity(value: number);
+    /********
+     * Camera */
+    get kingsyCamera(): KingSyCamera | null;
+    set kingsyCamera(value: KingSyCamera);
+    get renderingCamera(): PerspectiveCamera | OrthographicCamera | null;
+    /**********
+     * Pipeline */
+    set pipeline(value: Pipeline);
+    get pipeline(): Pipeline;
+    get shadowcatcher(): Shadowcatcher | null;
+    /**************
+     * Intersections */
+    get intersections(): Intersections;
+    /*****************
+     * Rendering Stats */
+    get renderingStats(): RenderingStats;
+    constructor(tree: WorldTree, viewer: Viewer /** TEMPORARY */);
+    create(container: HTMLElement): void;
+    update(deltaTime: number): void;
+    private updateRTEShadowBuffers;
+    private updateRTEShadows;
+    private updateTransforms;
+    resetPipeline(): void;
+    render(): void;
+    resize(width?: number, height?: number): void;
+    addRenderTree(renderTree: RenderTree): AsyncGenerator<undefined, void, unknown>;
+    private addBatch;
+    removeRenderTree(subtreeId: string): void;
+    cancelRenderTree(subtreeId: string): void;
+    setMaterial(rvs: NodeRenderView[], material: Material): void;
+    setMaterial(rvs: NodeRenderView[], material: RenderMaterial & DisplayStyle & MaterialOptions): void;
+    setMaterial(rvs: NodeRenderView[], material: FilterMaterial): void;
+    private setMaterialInstance;
+    private setFilterMaterial;
+    private setDataMaterial;
+    /** TO DO!
+     * This can mess up materials if multiple materials exist in the ranges argument */
+    private flattenDrawRanges;
+    getMaterial(rv: NodeRenderView): Material | null;
+    getBatchMaterial(rv: NodeRenderView): Material | null;
+    resetMaterials(): void;
+    getBatch(id: string): Batch;
+    updateClippingPlanes(): void;
+    updateShadowCatcher(force?: boolean): void;
+    private addDirectLights;
+    private updateDirectLights;
+    setSunLightConfiguration(config: SunLightConfiguration): void;
+    private updateHelpers;
+    queryHits(results: Array<ExtendedIntersection>): Array<{
+        node: TreeNode;
+        point: Vector3;
+    }> | null;
+    queryHitIds(results: Array<ExtendedIntersection>): Array<{
+        nodeId: string;
+        point: Vector3;
+    }> | null;
+    renderViewFromIntersection(intersection: ExtendedIntersection): NodeRenderView | null;
+    private onClick;
+    private onDoubleClick;
+    boxFromObjects(objectIds: string[]): Box3;
+    screenToNDC(clientX: number, clientY: number, width?: number, height?: number): {
+        x: number;
+        y: number;
+    };
+    NDCToScreen(clientX: number, clientY: number, width?: number, height?: number): {
+        x: number;
+        y: number;
+    };
+    debugShowBatches(): void;
+    getBatchIds(): string[];
+    getBatchSize(batchId: string): number;
+    isolateBatch(batchId: string): void;
+    getObjects(): BatchObject[];
+    getObject(rv: NodeRenderView): BatchObject | null;
+    enableLayers(layers: ObjectLayers[], value: boolean): void;
+}

package/dist/modules/LegacyViewer.d.ts

@@ -0,0 +1,77 @@
+import { type FilteringState } from './extensions/FilteringExtension.js';
+import { type InlineView, type PolarView, type CanonicalView } from './extensions/CameraController.js';
+import type { Query, QueryArgsResultMap, QueryResult } from './queries/Query.js';
+import { type KingSyView, type SunLightConfiguration, type ViewerParams } from '../IViewer.js';
+import { Viewer } from './Viewer.js';
+import { WorldTree } from './tree/WorldTree.js';
+import { type MeasurementOptions } from './extensions/measurements/MeasurementsExtension.js';
+import { type DiffResult, VisualDiffMode } from './extensions/DiffExtension.js';
+import { type PropertyInfo } from './filtering/PropertyManager.js';
+import { BatchObject } from './batching/BatchObject.js';
+import { KingSyViewer } from '@kingsy/shared';
+export declare class LegacyViewer extends Viewer {
+    private cameraController;
+    private selection;
+    private sections;
+    private measurements;
+    private filtering;
+    private explodeExtension;
+    private diffExtension;
+    private highlightExtension;
+    constructor(container: HTMLElement, params?: ViewerParams);
+    init(): Promise<void>;
+    getRenderer(): import("./KingSyRenderer.js").default;
+    /** SECTION BOX */
+    setSectionBox(boxData?: KingSyViewer.ViewerState.SectionBoxData, offset?: number): void;
+    getCurrentSectionBox(): KingSyViewer.ViewerState.SectionBoxData;
+    toggleSectionBox(): void;
+    sectionBoxOff(): void;
+    sectionBoxOn(): void;
+    /** FILTERING */
+    selectObjects(objectIds: string[]): Promise<FilteringState>;
+    resetSelection(): Promise<FilteringState>;
+    hideObjects(objectIds: string[], stateKey?: string | undefined, includeDescendants?: boolean, ghost?: boolean): Promise<FilteringState>;
+    showObjects(objectIds: string[], stateKey?: string | undefined, includeDescendants?: boolean): Promise<FilteringState>;
+    isolateObjects(objectIds: string[], stateKey?: string | undefined, includeDescendants?: boolean, ghost?: boolean): Promise<FilteringState>;
+    unIsolateObjects(objectIds: string[], stateKey?: string | undefined, includeDescendants?: boolean): Promise<FilteringState>;
+    highlightObjects(objectIds: string[]): Promise<FilteringState>;
+    resetHighlight(): Promise<FilteringState>;
+    setColorFilter(property: PropertyInfo, ghost?: boolean): Promise<FilteringState>;
+    removeColorFilter(): Promise<FilteringState>;
+    setUserObjectColors(groups: {
+        objectIds: string[];
+        color: string;
+    }[]): Promise<FilteringState>;
+    resetFilters(): Promise<FilteringState | null>;
+    private preserveSelectionHighlightFilter;
+    /** TREE */
+    getDataTree(): void;
+    getWorldTree(): WorldTree;
+    /** QUERIES */
+    query<T extends Query>(query: T): QueryArgsResultMap[T['operation']];
+    queryAsync(query: Query): Promise<QueryResult> | null;
+    /** CAMERA */
+    zoom(objectIds?: string[], fit?: number, transition?: boolean): void;
+    setOrthoCameraOn(): void;
+    setPerspectiveCameraOn(): void;
+    toggleCameraProjection(): void;
+    setLightConfiguration(config: SunLightConfiguration): void;
+    getViews(): KingSyView[];
+    setView(view: CanonicalView | KingSyView | InlineView | PolarView, transition?: boolean): void;
+    /** MISC */
+    screenshot(): Promise<string>;
+    explode(time: number): void;
+    getObjects(id: string): BatchObject[];
+    /**
+     * OBJECT LOADING/UNLOADING
+     */
+    loadObjectAsync(url: string, token?: string | undefined, enableCaching?: boolean, zoomToObject?: boolean): Promise<void>;
+    diff(urlA: string, urlB: string, mode: VisualDiffMode, authToken?: string): Promise<DiffResult>;
+    undiff(): Promise<void>;
+    setDiffTime(_diffResult: DiffResult, time: number): void;
+    setVisualDiffMode(_diffResult: DiffResult, mode: VisualDiffMode): void;
+    enableMeasurements(value: boolean): void;
+    setMeasurementOptions(options: MeasurementOptions): void;
+    removeMeasurement(): void;
+    dispose(): void;
+}

package/dist/modules/Shadowcatcher.d.ts

@@ -0,0 +1,25 @@
+import { Box3, Mesh, Plane, Scene } from 'three';
+import { ShadowcatcherPass } from './pipeline/Passes/ShadowcatcherPass.js';
+import { ObjectLayers } from '../IViewer.js';
+import { type ShadowcatcherConfig } from './ShadowcatcherConfig.js';
+import type { KingSyWebGLRenderer } from './objects/KingSyWebGLRenderer.js';
+export declare class Shadowcatcher {
+    static readonly MESH_NAME = "Shadowcatcher";
+    static readonly PLANE_SUBD = 2;
+    static readonly MAX_TEXTURE_SIZE_SCALE = 0.5;
+    private planeMesh;
+    private planeSize;
+    private displayMaterial;
+    shadowcatcherPass: ShadowcatcherPass;
+    private _config;
+    get shadowcatcherMesh(): Mesh<import("three").BufferGeometry, import("three").Material | import("three").Material[]>;
+    set configuration(config: ShadowcatcherConfig);
+    constructor(layer: ObjectLayers, renderlayers: Array<ObjectLayers>);
+    update(scene: Scene): void;
+    render(renderer: KingSyWebGLRenderer): void;
+    bake(worldBox: Box3, maxTexSize: number, force?: boolean): void;
+    updateClippingPlanes(planes: Plane[]): void;
+    private getTextureSize;
+    private updatePlaneMesh;
+    private updatePlaneMeshGeometry;
+}

package/dist/modules/ShadowcatcherConfig.d.ts

@@ -0,0 +1,14 @@
+export interface ShadowcatcherConfig {
+    textureSize: number;
+    weights: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    blurRadius: number;
+    stdDeviation: number;
+    sigmoidRange: number;
+    sigmoidStrength: number;
+}
+export declare const DefaultShadowcatcherConfig: ShadowcatcherConfig;

package/dist/modules/UrlHelper.d.ts

@@ -0,0 +1 @@
+export declare function getResourceUrls(url: string, authToken?: string): Promise<string[]>;

package/dist/modules/Utils.d.ts

@@ -0,0 +1,10 @@
+export interface Utils {
+    screenToNDC(x: number, y: number, width?: number, height?: number): {
+        x: number;
+        y: number;
+    };
+    NDCToScreen(x: number, y: number, width?: number, height?: number): {
+        x: number;
+        y: number;
+    };
+}

package/dist/modules/Viewer.d.ts

@@ -0,0 +1,74 @@
+import EventEmitter from './EventEmitter.js';
+import { Clock } from 'three';
+import { Assets } from './Assets.js';
+import { type Optional } from '../helpers/typeHelper.js';
+import { type IViewer, type KingSyView, type SunLightConfiguration, UpdateFlags, ViewerEvent, type ViewerParams, type ViewerEventPayload } from '../IViewer.js';
+import { World } from './World.js';
+import { WorldTree } from './tree/WorldTree.js';
+import KingSyRenderer from './KingSyRenderer.js';
+import { type PropertyInfo, PropertyManager } from './filtering/PropertyManager.js';
+import type { Query, QueryArgsResultMap } from './queries/Query.js';
+import { type Utils } from './Utils.js';
+import { Extension } from './extensions/Extension.js';
+import Input from './input/Input.js';
+import { Loader } from './loaders/Loader.js';
+import { type Constructor } from 'type-fest';
+import Stats from './three/stats.js';
+export declare class Viewer extends EventEmitter implements IViewer {
+    /** Container and optional stats element */
+    protected container: HTMLElement;
+    protected stats: Optional<ReturnType<typeof Stats>>;
+    /** Viewer params used at init time */
+    protected startupParams: ViewerParams;
+    /** Viewer components */
+    protected tree: WorldTree;
+    protected world: World;
+    static readonly theAssets: Assets;
+    kingsyRenderer: KingSyRenderer;
+    protected propertyManager: PropertyManager;
+    /** Misc members */
+    protected inProgressOperations: number;
+    protected clock: Clock;
+    protected loaders: {
+        [id: string]: Loader;
+    };
+    protected extensions: {
+        [id: string]: Extension;
+    };
+    /** various utils/helpers */
+    protected utils: Utils | undefined;
+    /** Gets the World object. Currently it's used for info mostly */
+    get World(): World;
+    get Utils(): Utils;
+    get input(): Input;
+    private getConstructorChain;
+    createExtension<T extends Extension>(type: Constructor<T>): T;
+    getExtension<T extends Extension>(type: Constructor<T>): T;
+    hasExtension<T extends Extension>(type: Constructor<T>): boolean;
+    private getExtensionInternal;
+    constructor(container: HTMLElement, params?: ViewerParams);
+    getContainer(): HTMLElement;
+    getRenderer(): KingSyRenderer;
+    resize(): void;
+    requestRender(flags?: UpdateFlags): void;
+    protected frame(): void;
+    protected update(): void;
+    protected render(): void;
+    init(): Promise<void>;
+    on<T extends ViewerEvent>(eventType: T, listener: (arg: ViewerEventPayload[T]) => void): void;
+    getObjectProperties(resourceURL?: string | null, bypassCache?: boolean): Promise<PropertyInfo[]>;
+    getDataTree(): void;
+    getWorldTree(): WorldTree;
+    query<T extends Query>(query: T): QueryArgsResultMap[T['operation']] | null;
+    setLightConfiguration(config: SunLightConfiguration): void;
+    getViews(): KingSyView[];
+    screenshot(): Promise<string>;
+    /**
+     * OBJECT LOADING/UNLOADING
+     */
+    loadObject(loader: Loader, zoomToObject?: boolean): Promise<void>;
+    cancelLoad(resource: string, unload?: boolean): Promise<void>;
+    unloadObject(resource: string): Promise<void>;
+    unloadAll(): Promise<void>;
+    dispose(): void;
+}

package/dist/modules/WebXrViewer.d.ts

@@ -0,0 +1,10 @@
+import { Viewer } from './Viewer.js';
+export declare class WebXrViewer extends Viewer {
+    init(): Promise<void>;
+    /** Override the render function an don't call KingSyRendere's render */
+    protected render(): void;
+    /** Rendering is now done on three's WebXr loop
+     *  We also just render plainly, no pipelines, for simplicity
+     */
+    protected xrWrappedRender(): void;
+}

package/dist/modules/World.d.ts

@@ -0,0 +1,31 @@
+import { Box3, Vector3 } from 'three';
+import { OBB } from 'three/examples/jsm/math/OBB.js';
+export declare class AsyncPause {
+    private lastPauseTime;
+    needsWait: boolean;
+    tick(maxDelta: number): void;
+    wait(waitTime: number): Promise<void>;
+}
+export declare class World {
+    private readonly boxes;
+    readonly worldBox: Box3;
+    private readonly VecBuff;
+    private readonly BoxBuff0;
+    private readonly BoxBuff1;
+    private _worldOrigin;
+    get worldSize(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    get worldOrigin(): Vector3;
+    expandWorld(box: Box3): void;
+    reduceWorld(box: Box3): void;
+    updateWorld(): void;
+    resetWorld(): void;
+    getRelativeOffset(offsetAmount?: number): number;
+    getRelativeOffsetBox(box: Box3, offsetAmount?: number): Box3;
+    static expandBoxRelative<T extends OBB | Box3>(box: T, offsetAmount?: number): T;
+    private static expandBox3Relative;
+    private static expandOBBRelative;
+}

package/dist/modules/batching/Batch.d.ts

@@ -0,0 +1,62 @@
+import { Box3, Material, Object3D, WebGLRenderer } from 'three';
+import { type FilterMaterialOptions } from '../materials/Materials.js';
+import { NodeRenderView } from '../tree/NodeRenderView.js';
+export declare enum GeometryType {
+    MESH = 0,
+    LINE = 1,
+    POINT = 2,
+    POINT_CLOUD = 3,
+    TEXT = 4
+}
+export interface DrawGroup {
+    start: number;
+    count: number;
+    materialIndex: number;
+}
+/** TO DO: Unify point and mesh batch implementations */
+export interface Batch {
+    id: string;
+    subtreeId: string;
+    renderViews: NodeRenderView[];
+    batchMaterial: Material;
+    renderObject: Object3D;
+    geometryType: GeometryType;
+    get bounds(): Box3;
+    get drawCalls(): number;
+    get minDrawCalls(): number;
+    get materials(): Material[];
+    get groups(): DrawGroup[];
+    get triCount(): number;
+    get pointCount(): number;
+    get lineCount(): number;
+    get vertCount(): number;
+    getCount(): number;
+    setBatchMaterial(material: Material): void;
+    setBatchBuffers(range: BatchUpdateRange[]): void;
+    setVisibleRange(range: BatchUpdateRange[]): void;
+    getVisibleRange(): BatchUpdateRange;
+    setDrawRanges(ranges: BatchUpdateRange[]): void;
+    resetDrawRanges(): void;
+    buildBatch(): Promise<void>;
+    getRenderView(index: number): NodeRenderView | null;
+    getMaterialAtIndex(index: number): Material | null;
+    getMaterial(rv: NodeRenderView): Material | null;
+    getOpaque(): BatchUpdateRange;
+    getTransparent(): BatchUpdateRange;
+    getStencil(): BatchUpdateRange;
+    getDepth(): BatchUpdateRange;
+    onUpdate(deltaTime?: number): void;
+    onRender?(renderer: WebGLRenderer): void;
+    purge(): void;
+}
+export interface BatchUpdateRange {
+    offset: number;
+    count: number;
+    material?: Material;
+    materialOptions?: FilterMaterialOptions;
+}
+export declare const NoneBatchUpdateRange: BatchUpdateRange;
+export declare const AllBatchUpdateRange: BatchUpdateRange;
+export declare const INSTANCE_TRANSFORM_BUFFER_STRIDE = 16;
+export declare const INSTANCE_GRADIENT_BUFFER_STRIDE = 1;
+export declare const getNextBatchIndex: () => number;

package/dist/modules/batching/BatchObject.d.ts

@@ -0,0 +1,53 @@
+import { Box3, Euler, Matrix4, Quaternion, Vector3 } from 'three';
+import { NodeRenderView } from '../tree/NodeRenderView.js';
+import { AccelerationStructure } from '../objects/AccelerationStructure.js';
+import { MeshBVH } from 'three-mesh-bvh';
+export type VectorLike = {
+    x: number;
+    y: number;
+    z?: number;
+    w?: number;
+} | undefined | null;
+export type Vector3Like = VectorLike & {
+    z: number;
+};
+export type Vector4Like = Vector3Like & {
+    w: number;
+};
+export declare class BatchObject {
+    protected _renderView: NodeRenderView;
+    protected _accelerationStructure: AccelerationStructure;
+    protected _batchIndex: number;
+    protected _localOrigin: Vector3;
+    transform: Matrix4;
+    transformInv: Matrix4;
+    tasVertIndexStart: number;
+    tasVertIndexEnd: number;
+    quaternion: Quaternion;
+    eulerValue: Euler;
+    pivot_High: Vector3;
+    pivot_Low: Vector3;
+    translation: Vector3;
+    scaleValue: Vector3;
+    pivotValue: Vector3;
+    protected static matBuff0: Matrix4;
+    protected static matBuff1: Matrix4;
+    protected static matBuff2: Matrix4;
+    protected static eulerBuff: Euler;
+    protected static translationBuff: Vector3;
+    protected static scaleBuff: Vector3;
+    protected static pivotBuff: Vector3;
+    transformDirty: boolean;
+    get renderView(): NodeRenderView;
+    get accelerationStructure(): AccelerationStructure;
+    get batchIndex(): number;
+    get aabb(): Box3;
+    get localOrigin(): Vector3;
+    set pivot(value: Vector3 | null);
+    set position(value: Vector3);
+    set euler(euler: Euler);
+    set scale(scale: Vector3);
+    constructor(renderView: NodeRenderView, batchIndex: number);
+    buildAccelerationStructure(bvh?: MeshBVH): void;
+    transformTRS(translation: Vector3Like, euler?: Vector3Like, scale?: Vector3Like, pivot?: Vector3Like): void;
+}

package/dist/modules/batching/Batcher.d.ts

@@ -0,0 +1,60 @@
+import { WebGLCapabilities } from 'three';
+import LineBatch from './LineBatch.js';
+import Materials from '../materials/Materials.js';
+import { NodeRenderView } from '../tree/NodeRenderView.js';
+import { type Batch, type BatchUpdateRange, GeometryType } from './Batch.js';
+import { Material, WebGLRenderer } from 'three';
+import { RenderTree } from '../tree/RenderTree.js';
+import TextBatch from './TextBatch.js';
+import { KingSyType } from '../loaders/GeometryConverter.js';
+import { WorldTree } from '../../index.js';
+import { MeshBatch } from './MeshBatch.js';
+import { PointBatch } from './PointBatch.js';
+import { ObjectVisibility } from '../pipeline/Passes/GPass.js';
+type BatchTypeMap = {
+    [GeometryType.MESH]: MeshBatch;
+    [GeometryType.LINE]: LineBatch;
+    [GeometryType.POINT]: PointBatch;
+    [GeometryType.POINT_CLOUD]: PointBatch;
+    [GeometryType.TEXT]: TextBatch;
+};
+export default class Batcher {
+    private caps;
+    private maxBatchObjects;
+    private maxBatchVertices;
+    private minInstancedBatchVertices;
+    materials: Materials;
+    batches: {
+        [id: string]: Batch;
+    };
+    constructor(caps: WebGLCapabilities);
+    makeBatches(worldTree: WorldTree, renderTree: RenderTree, kingsyType: KingSyType[], batchType?: GeometryType): AsyncGenerator<Batch, void, unknown>;
+    private splitBatch;
+    private buildInstancedBatch;
+    private buildBatch;
+    update(deltaTime: number): void;
+    render(renderer: WebGLRenderer): void;
+    saveVisiblity(): Record<string, BatchUpdateRange>;
+    applyVisibility(ranges: Record<string, BatchUpdateRange>): void;
+    getVisibility(objectVisibility: ObjectVisibility): Record<string, BatchUpdateRange>;
+    getTransparent(): Record<string, BatchUpdateRange>;
+    getStencil(): Record<string, BatchUpdateRange>;
+    getOpaque(): Record<string, BatchUpdateRange>;
+    getDepth(): Record<string, BatchUpdateRange>;
+    overrideMaterial(ranges: Record<string, BatchUpdateRange>, material: Material): void;
+    overrideBatchMaterial(ranges: Record<string, BatchUpdateRange>, material: Material): void;
+    restoreMaterial(ranges: Record<string, BatchUpdateRange>): void;
+    restoreBatchMaterial(ranges: Record<string, BatchUpdateRange>): void;
+    purgeBatches(subtreeId: string): void;
+    getBatches<K extends GeometryType>(subtreeId?: string, geometryType?: K): BatchTypeMap[K][];
+    private isBatchType;
+    getBatch(rv: NodeRenderView): Batch | undefined;
+    getRenderView(batchId: string, index: number): NodeRenderView | null;
+    getRenderViewMaterial(batchId: string, index: number): Material | null;
+    resetBatchesDrawRanges(): void;
+    /**
+     * Used for debuggin only
+     */
+    isolateBatch(batchId: string): void;
+}
+export {};

package/dist/modules/batching/DrawRanges.d.ts

@@ -0,0 +1,6 @@
+import { Material } from 'three';
+import { type BatchUpdateRange } from './Batch.js';
+import { type DrawGroup } from './Batch.js';
+export declare class DrawRanges {
+    integrateRanges(groups: Array<DrawGroup>, materials: Array<Material>, ranges: BatchUpdateRange[]): Array<DrawGroup>;
+}

package/dist/modules/batching/InstancedBatchObject.d.ts

@@ -0,0 +1,8 @@
+import { BatchObject, type Vector3Like } from './BatchObject.js';
+import { Matrix4 } from 'three';
+import { NodeRenderView } from '../tree/NodeRenderView.js';
+export declare class InstancedBatchObject extends BatchObject {
+    protected instanceTransform: Matrix4;
+    constructor(renderView: NodeRenderView, batchIndex: number);
+    transformTRS(translation: Vector3Like, euler: Vector3Like, scale: Vector3Like, pivot: Vector3Like): void;
+}