@thatopen/components 2.4.11 → 3.1.0

package/dist/core/Cullers/src/culler-renderer.d.ts

@@ -1,76 +0,0 @@
-import * as THREE from "three";
-import { Components } from "../../Components";
-import { AsyncEvent, Configurable, Event, World } from "../../Types";
-import { CullerRendererConfig, CullerRendererConfigManager } from "./culler-renderer-config";
-/**
- * A base renderer to determine visibility on screen.
- */
-export declare class CullerRenderer implements Configurable<CullerRendererConfigManager, CullerRendererConfig> {
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Fires after making the visibility check to the meshes. It lists the
-     * meshes that are currently visible, and the ones that were visible
-     * just before but not anymore.
-     */
-    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
-    /**
-     * Whether this renderer is active or not. If not, it won't render anything.
-     */
-    enabled: boolean;
-    /**
-     * Needs to check whether there are objects that need to be hidden or shown.
-     * You can bind this to the camera movement, to a certain interval, etc.
-     */
-    needsUpdate: boolean;
-    /** The components instance to which this renderer belongs. */
-    components: Components;
-    /** The render target used to render the visibility scene. */
-    renderTarget: THREE.WebGLRenderTarget<THREE.Texture>;
-    /**
-     * The size of the buffer where the result of the visibility check is stored.
-     */
-    bufferSize: number;
-    /**
-     * The buffer when the result of the visibility check is stored.
-     */
-    buffer: Uint8Array;
-    /**
-     * Flag to indicate if the renderer shouldn't update the visibility.
-     */
-    preventUpdate: boolean;
-    /** {@link Configurable.config} */
-    config: CullerRendererConfigManager;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /** The world instance to which this renderer belongs. */
-    readonly world: World;
-    /** The THREE.js renderer used to make the visibility test. */
-    readonly renderer: THREE.WebGLRenderer;
-    protected _defaultConfig: CullerRendererConfig;
-    protected readonly worker: Worker;
-    protected readonly scene: THREE.Scene;
-    private _availableColor;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * The function that the culler uses to reprocess the scene. Generally it's
-     * better to call needsUpdate, but you can also call this to force it.
-     * @param force if true, it will refresh the scene even if needsUpdate is
-     * not true.
-     */
-    updateVisibility: (force?: boolean) => Promise<void>;
-    setup(config?: Partial<CullerRendererConfig>): void;
-    protected getAvailableColor(): {
-        r: number;
-        g: number;
-        b: number;
-        code: string;
-    };
-    protected increaseColor(): void;
-    protected decreaseColor(): void;
-}

package/dist/core/Cullers/src/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./culler-renderer";
-export * from "./mesh-culler-renderer";
-export * from "./screen-culler-helper";

package/dist/core/Cullers/src/mesh-culler-renderer.d.ts

@@ -1,59 +0,0 @@
-import * as THREE from "three";
-import { CullerRenderer } from "./culler-renderer";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-/**
- * A renderer to hide/show meshes depending on their visibility from the user's point of view.
- */
-export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
-    /**
-     * Event triggered when the visibility of meshes is updated.
-     * Contains two sets: seen and unseen.
-     */
-    readonly onViewUpdated: Event<{
-        seen: Set<THREE.Mesh>;
-        unseen: Set<THREE.Mesh>;
-    }>;
-    /**
-     * Map of color code to THREE.InstancedMesh.
-     * Used to keep track of color-coded meshes.
-     */
-    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.InstancedMeshEventMap>>;
-    /**
-     * @deprecated use config.threshold instead.
-     */
-    get threshold(): number;
-    /**
-     * @deprecated use config.threshold instead.
-     */
-    set threshold(value: number);
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
-     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     */
-    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    /**
-     * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
-     * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
-     * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     */
-    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    /**
-     * Updates the given instanced meshes inside the culler. You should use this if you change the count property, e.g. when changing the visibility of fragments.
-     *
-     * @param meshes - The meshes to update.
-     *
-     * @returns {void}
-     */
-    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
-    private handleWorkerMessage;
-    private getAvailableMaterial;
-}

package/dist/core/Cullers/src/screen-culler-helper.d.ts

@@ -1 +0,0 @@
-export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;

package/dist/core/Disposer/index.d.ts

@@ -1,45 +0,0 @@
-import * as THREE from "three";
-import { Components } from "../Components";
-import { Component } from "../Types";
-/**
- * A tool to safely remove meshes, geometries, materials and other items from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
- */
-export declare class Disposer extends Component {
-    private _disposedComponents;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
-    constructor(components: Components);
-    /**
-     * Return the UUIDs of all disposed components.
-     */
-    get(): Set<string>;
-    /**
-     * Removes a mesh, its geometry and its materials from memory. If you are
-     * using any of these in other parts of the application, make sure that you
-     * remove them from the mesh before disposing it.
-     *
-     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
-     * to remove.
-     *
-     * @param materials - whether to dispose the materials of the mesh.
-     *
-     * @param recursive - whether to recursively dispose the children of the mesh.
-     */
-    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
-    /**
-     * Disposes a geometry from memory.
-     *
-     * @param geometry - the
-     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
-     * to remove.
-     */
-    disposeGeometry(geometry: THREE.BufferGeometry): void;
-    private disposeGeometryAndMaterials;
-    private disposeChildren;
-    private static disposeMaterial;
-}

package/dist/core/Grids/index.d.ts

@@ -1,46 +0,0 @@
-import { Component, Disposable, World, Event } from "../Types";
-import { SimpleGrid } from "./src";
-import { Components } from "../Components";
-export * from "./src";
-/**
- * A component that manages grid instances. Each grid is associated with a unique world. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Grids). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Grids).
- */
-export declare class Grids extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
-    /**
-     * A map of world UUIDs to their corresponding grid instances.
-     */
-    list: Map<string, SimpleGrid>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Creates a new grid for the given world.
-     * Throws an error if a grid already exists for the world.
-     *
-     * @param world - The world to create the grid for.
-     * @returns The newly created grid.
-     *
-     * @throws Will throw an error if a grid already exists for the given world.
-     */
-    create(world: World): SimpleGrid;
-    /**
-     * Deletes the grid associated with the given world.
-     * If a grid does not exist for the given world, this method does nothing.
-     *
-     * @param world - The world for which to delete the grid.
-     *
-     * @remarks
-     * This method will dispose of the grid and remove it from the internal list.
-     * If the world is disposed before calling this method, the grid will be automatically deleted.
-     */
-    delete(world: World): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-}

package/dist/core/Grids/src/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./simple-grid";
-export * from "./simple-grid-config";

package/dist/core/Grids/src/simple-grid-config.d.ts

@@ -1,80 +0,0 @@
-import * as THREE from "three";
-import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
-import { Configurator } from "../../ConfigManager";
-import { SimpleGrid } from "./simple-grid";
-type SimpleGridConfigType = {
-    visible: BooleanSettingsControl;
-    color: ColorSettingsControl;
-    primarySize: NumberSettingControl;
-    secondarySize: NumberSettingControl;
-    distance: NumberSettingControl;
-};
-/**
- * Configuration interface for the {@link SimpleGrid}.
- */
-export interface SimpleGridConfig {
-    /**
-     * Whether the grid is visible or not.
-     */
-    visible: boolean;
-    /**
-     * The color of the grid lines.
-     */
-    color: THREE.Color;
-    /**
-     * The size of the primary grid lines.
-     */
-    primarySize: number;
-    /**
-     * The size of the secondary grid lines.
-     */
-    secondarySize: number;
-    /**
-     * The distance at which the grid lines start to fade away.
-     */
-    distance: number;
-}
-export declare class SimpleGridConfigManager extends Configurator<SimpleGrid, SimpleGridConfigType> {
-    protected _config: SimpleGridConfigType;
-    /**
-     * Whether the grid is visible or not.
-     */
-    get visible(): boolean;
-    /**
-     * Whether the grid is visible or not.
-     */
-    set visible(value: boolean);
-    /**
-     * The color of the grid lines.
-     */
-    get color(): THREE.Color;
-    /**
-     * The color of the grid lines.
-     */
-    set color(value: THREE.Color);
-    /**
-     * The size of the primary grid lines.
-     */
-    get primarySize(): number;
-    /**
-     * The size of the primary grid lines.
-     */
-    set primarySize(value: number);
-    /**
-     * The size of the secondary grid lines.
-     */
-    get secondarySize(): number;
-    /**
-     * The size of the secondary grid lines.
-     */
-    set secondarySize(value: number);
-    /**
-     * The distance at which the grid lines start to fade away.
-     */
-    get distance(): number;
-    /**
-     * The distance at which the grid lines start to fade away.
-     */
-    set distance(value: number);
-}
-export {};

package/dist/core/Grids/src/simple-grid.d.ts

@@ -1,48 +0,0 @@
-import * as THREE from "three";
-import { Hideable, Event, World, Disposable, Configurable } from "../../Types";
-import { Components } from "../../Components";
-import { SimpleGridConfig, SimpleGridConfigManager } from "./simple-grid-config";
-/**
- * An infinite grid. Created by [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper) and translated to typescript by [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
- */
-export declare class SimpleGrid implements Hideable, Disposable, Configurable<SimpleGridConfigManager, SimpleGridConfig> {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /** The world instance to which this Raycaster belongs. */
-    world: World;
-    /** The components instance to which this grid belongs. */
-    components: Components;
-    /** {@link Configurable.config} */
-    config: SimpleGridConfigManager;
-    protected _defaultConfig: SimpleGridConfig;
-    /** {@link Hideable.visible} */
-    get visible(): boolean;
-    /** {@link Hideable.visible} */
-    set visible(visible: boolean);
-    /** The material of the grid. */
-    get material(): THREE.ShaderMaterial;
-    /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
-     */
-    get fade(): boolean;
-    /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
-     */
-    set fade(active: boolean);
-    /** The Three.js mesh that contains the infinite grid. */
-    readonly three: THREE.Mesh;
-    private _fade;
-    constructor(components: Components, world: World);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleGridConfig>): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private setupEvents;
-    private updateZoom;
-}

package/dist/core/MiniMap/index.d.ts

@@ -1,50 +0,0 @@
-import { MiniMap } from "./src";
-import { Component, Updateable, World, Event, Disposable } from "../Types";
-import { Components } from "../Components";
-export * from "./src";
-/**
- * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MiniMap). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MiniMaps).
- */
-export declare class MiniMaps extends Component implements Updateable, Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
-     */
-    list: Map<string, MiniMap>;
-    constructor(components: Components);
-    /**
-     * Creates a new {@link MiniMap} instance associated with the given world.
-     * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
-     *
-     * @param world - The {@link World} for which to create a {@link MiniMap} instance.
-     * @returns The newly created {@link MiniMap} instance.
-     * @throws Will throw an error if a {@link MiniMap} instance already exists for the given world.
-     */
-    create(world: World): MiniMap;
-    /**
-     * Deletes a {@link MiniMap} instance associated with the given world ID.
-     * If a {@link MiniMap} instance does not exist for the given ID, nothing happens.
-     *
-     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
-     * @returns {void}
-     */
-    delete(id: string): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(): void;
-}

package/dist/core/MiniMap/src/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./mini-map";
-export * from "./mini-map-config";

package/dist/core/MiniMap/src/mini-map-config.d.ts

@@ -1,112 +0,0 @@
-import * as THREE from "three";
-import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
-import { Configurator } from "../../ConfigManager";
-import { MiniMap } from "./index";
-type MiniMapConfigType = {
-    visible: BooleanSettingsControl;
-    lockRotation: BooleanSettingsControl;
-    zoom: NumberSettingControl;
-    frontOffset: NumberSettingControl;
-    sizeX: NumberSettingControl;
-    sizeY: NumberSettingControl;
-    backgroundColor: ColorSettingsControl;
-};
-/**
- * Configuration interface for the {@link MiniMap}.
- */
-export interface MiniMapConfig {
-    /**
-     * Whether the minimap is visible or not.
-     */
-    visible: boolean;
-    /**
-     * Whether to lock the rotation of the top camera in the minimap.
-     */
-    lockRotation: boolean;
-    /**
-     * The zoom of the camera in the minimap.
-     */
-    zoom: number;
-    /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
-     */
-    frontOffset: number;
-    /**
-     * The horizontal dimension of the minimap.
-     */
-    sizeX: number;
-    /**
-     * The vertical dimension of the minimap.
-     */
-    sizeY: number;
-    /**
-     * The color of the background of the minimap.
-     */
-    backgroundColor: THREE.Color;
-}
-export declare class MiniMapConfigManager extends Configurator<MiniMap, MiniMapConfigType> {
-    protected _config: MiniMapConfigType;
-    /**
-     * Whether the minimap is visible or not.
-     */
-    get visible(): boolean;
-    /**
-     * Whether the minimap is visible or not.
-     */
-    set visible(value: boolean);
-    /**
-     * Whether to lock the rotation of the top camera in the minimap.
-     */
-    get lockRotation(): boolean;
-    /**
-     * Whether to lock the rotation of the top camera in the minimap.
-     */
-    set lockRotation(value: boolean);
-    /**
-     * The zoom of the camera in the minimap.
-     */
-    get zoom(): number;
-    /**
-     * The zoom of the camera in the minimap.
-     */
-    set zoom(value: number);
-    /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
-     */
-    get frontOffset(): number;
-    /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
-     */
-    set frontOffset(value: number);
-    /**
-     * The horizontal dimension of the minimap.
-     */
-    get sizeX(): number;
-    /**
-     * The horizontal dimension of the minimap.
-     */
-    set sizeX(value: number);
-    /**
-     * The vertical dimension of the minimap.
-     */
-    get sizeY(): number;
-    /**
-     * The vertical dimension of the minimap.
-     */
-    set sizeY(value: number);
-    /**
-     * The color of the background of the minimap.
-     */
-    get backgroundColor(): THREE.Color;
-    /**
-     * The color of the background of the minimap.
-     */
-    set backgroundColor(value: THREE.Color);
-}
-export {};

package/dist/core/MiniMap/src/mini-map.d.ts

@@ -1,100 +0,0 @@
-import * as THREE from "three";
-import { Resizeable, Updateable, World, Event, Disposable, Configurable } from "../../Types";
-import { MiniMapConfig, MiniMapConfigManager } from "./mini-map-config";
-import { Components } from "../../Components";
-/**
- * A class representing a 2D minimap of a 3D world.
- */
-export declare class MiniMap implements Resizeable, Updateable, Disposable, Configurable<MiniMapConfigManager, MiniMapConfig> {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Resizeable.onResize} */
-    readonly onResize: Event<THREE.Vector2>;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
-     */
-    frontOffset: number;
-    /**
-     * The override material for the minimap.
-     * It is used to render the depth information of the world onto the minimap.
-     */
-    overrideMaterial: THREE.MeshDepthMaterial;
-    /**
-     * The background color of the minimap.
-     * It is used to set the background color of the minimap's renderer.
-     */
-    backgroundColor: THREE.Color;
-    /**
-     * The WebGL renderer for the minimap.
-     * It is used to render the minimap onto the screen.
-     */
-    renderer: THREE.WebGLRenderer;
-    /**
-     * A flag indicating whether the minimap is enabled.
-     * If disabled, the minimap will not update or render.
-     */
-    enabled: boolean;
-    /**
-     * The world in which the minimap is displayed.
-     * It provides access to the 3D scene, camera, and other relevant world elements.
-     */
-    world: World;
-    /** {@link Configurable.config} */
-    config: MiniMapConfigManager;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    protected _defaultConfig: MiniMapConfig;
-    private _lockRotation;
-    private _size;
-    private _camera;
-    private _plane;
-    private _tempVector1;
-    private _tempVector2;
-    private _tempTarget;
-    private readonly down;
-    /**
-     * Gets or sets whether the minimap rotation is locked.
-     * When rotation is locked, the minimap will always face the same direction as the camera.
-     */
-    get lockRotation(): boolean;
-    /**
-     * Sets whether the minimap rotation is locked.
-     * When rotation is locked, the minimap will always face the same direction as the camera.
-     * @param active - If `true`, rotation is locked. If `false`, rotation is not locked.
-     */
-    set lockRotation(active: boolean);
-    /**
-     * Gets the current zoom level of the minimap.
-     * The zoom level determines how much of the world is visible on the minimap.
-     * @returns The current zoom level of the minimap.
-     */
-    get zoom(): number;
-    /**
-     * Sets the zoom level of the minimap.
-     * The zoom level determines how much of the world is visible on the minimap.
-     * @param value - The new zoom level of the minimap.
-     */
-    set zoom(value: number);
-    constructor(world: World, components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** Returns the camera used by the MiniMap */
-    get(): THREE.OrthographicCamera;
-    /** {@link Updateable.update} */
-    update(): void;
-    /** {@link Resizeable.getSize} */
-    getSize(): THREE.Vector2;
-    /** {@link Resizeable.resize} */
-    resize(size?: THREE.Vector2): void;
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<MiniMapConfig>): void;
-    private updatePlanes;
-}