@thatopen/components 2.3.0-alpha.5 → 2.3.0-alpha.7

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

@@ -1,7 +1,8 @@
 import * as THREE from "three";
-import { Component, Createable, Disposable, Event, Hideable, World } from "../Types";
+import { Component, Configurable, Createable, Disposable, Event, Hideable, World } from "../Types";
 import { SimplePlane } from "./src";
 import { Components } from "../Components";
+import { ClipperConfig, ClipperConfigManager } from "./src/clipper-config";
 export * from "./src";
 /**
  * A lightweight component to easily create, delete and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Clipper). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Clipper).
@@ -9,12 +10,14 @@ export * from "./src";
  * @param components - the instance of {@link Components} used.
  * E.g. {@link SimplePlane}.
  */
-export declare class Clipper extends Component implements Createable, Disposable, Hideable {
+export declare class Clipper extends Component implements Createable, Disposable, Hideable, Configurable<ClipperConfigManager, ClipperConfig> {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
     static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
     /** Event that fires when the user starts dragging a clipping plane. */
     readonly onBeforeDrag: Event<void>;
     /** Event that fires when the user stops dragging a clipping plane. */
@@ -47,6 +50,8 @@ export declare class Clipper extends Component implements Createable, Disposable
     readonly onAfterDelete: Event<SimplePlane>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
     /**
      * Whether to force the clipping plane to be orthogonal in the Y direction
      * (up). This is desirable when clipping a building horizontally and a
@@ -69,6 +74,9 @@ export declare class Clipper extends Component implements Createable, Disposable
      * A list of all the clipping planes created by this component.
      */
     list: SimplePlane[];
+    /** {@link Configurable.config} */
+    config: ClipperConfigManager;
+    protected _defaultConfig: ClipperConfig;
     /** The material used in all the clipping planes. */
     private _material;
     private _size;
@@ -119,6 +127,8 @@ export declare class Clipper extends Component implements Createable, Disposable
      * @param types - the types of planes to be deleted. If not provided, all planes will be deleted.
      */
     deleteAll(types?: Set<string>): void;
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<ClipperConfig>): void;
     private deletePlane;
     private pickPlane;
     private getAllPlaneMeshes;

package/dist/core/Clipper/src/clipper-config.d.ts

@@ -0,0 +1,33 @@
+import * as THREE from "three";
+import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
+import { Configurator } from "../../ConfigManager";
+import { Clipper } from "../index";
+type ClipperConfigType = {
+    enabled: BooleanSettingsControl;
+    visible: BooleanSettingsControl;
+    color: ColorSettingsControl;
+    opacity: NumberSettingControl;
+    size: NumberSettingControl;
+};
+/**
+ * Configuration interface for the {@link Clipper}.
+ */
+export interface ClipperConfig {
+    color: THREE.Color;
+    opacity: number;
+    size: number;
+}
+export declare class ClipperConfigManager extends Configurator<Clipper, ClipperConfigType> {
+    protected _config: ClipperConfigType;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    get visible(): boolean;
+    set visible(value: boolean);
+    get color(): THREE.Color;
+    set color(value: THREE.Color);
+    get opacity(): number;
+    set opacity(value: number);
+    get size(): number;
+    set size(value: number);
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { Component, DataSet } from "../Types";
+import { Components } from "../Components";
+import { Configurator } from "./src";
+export * from "./src";
+/**
+ * A tool to manage all the configuration from the app centrally.
+ */
+export declare class ConfigManager extends Component {
+    /**
+     * The list of all configurations of this app.
+     */
+    list: DataSet<Configurator<any, any>>;
+    /** {@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: "b8c764e0-6b24-4e77-9a32-35fa728ee5b4";
+    constructor(components: Components);
+}

package/dist/core/ConfigManager/src/configurator.d.ts

@@ -0,0 +1,10 @@
+import { ControlsSchema, ControlEntry } from "../../Types";
+import { Components } from "../../Components";
+export declare abstract class Configurator<T, U extends ControlsSchema> {
+    protected abstract _config: U;
+    protected _component: T;
+    name: string;
+    get controls(): U;
+    constructor(component: T, components: Components, name: string);
+    copyEntry(controlEntry: ControlEntry): ControlEntry;
+}

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

@@ -0,0 +1 @@
+export * from "./configurator";

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

@@ -1,6 +1,6 @@
 import * as THREE from "three";
 import { Components } from "../Components";
-import { MeshCullerRenderer, CullerRendererSettings } from "./src";
+import { MeshCullerRenderer } from "./src";
 import { Component, Event, Disposable, World } from "../Types";
 export * from "./src";
 /**
@@ -31,11 +31,10 @@ export declare class Cullers extends Component implements Disposable {
      * If a MeshCullerRenderer already exists for the world, it will return the existing one.
      *
      * @param world - The world for which to create the MeshCullerRenderer.
-     * @param config - Optional configuration settings for the MeshCullerRenderer.
      *
      * @returns The newly created or existing MeshCullerRenderer for the given world.
      */
-    create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
+    create(world: World): MeshCullerRenderer;
     /**
      * Deletes the MeshCullerRenderer associated with the given world.
      * If a MeshCullerRenderer exists for the given world, it will be disposed and removed from the list.
@@ -52,7 +51,6 @@ export declare class Cullers extends Component implements Disposable {
      *
      * @param meshes - The meshes to update.
      *
-     * @returns {void}
      */
     updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
 }

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

@@ -0,0 +1,74 @@
+import { BooleanSettingsControl, NumberSettingControl } from "../../Types";
+import { Configurator } from "../../ConfigManager";
+import { CullerRenderer } from "../index";
+type CullerRendererConfigType = {
+    enabled: BooleanSettingsControl;
+    width: NumberSettingControl;
+    height: NumberSettingControl;
+    updateInterval: NumberSettingControl;
+    autoUpdate: BooleanSettingsControl;
+    renderDebugFrame: BooleanSettingsControl;
+    threshold: NumberSettingControl;
+};
+/**
+ * Configuration interface for the {@link CullerRenderer}.
+ */
+export interface CullerRendererConfig {
+    /**
+     * Whether the culler renderer should make renders or not.
+     */
+    enabled: boolean;
+    /**
+     * Width of the render target used for visibility checks.
+     */
+    width: number;
+    /**
+     * Height of the render target used for visibility checks.
+     * Default value is 512.
+     */
+    height: number;
+    /**
+     * Whether the visibility check should be performed automatically.
+     * Default value is true.
+     */
+    autoUpdate: boolean;
+    /**
+     * Interval in milliseconds at which the visibility check should be performed.
+     */
+    updateInterval: number;
+    /**
+     * Whether to render the frame use to debug the culler behavior.
+     */
+    renderDebugFrame: boolean;
+    /**
+     * Pixels in screen a geometry must occupy to be considered "seen".
+     * Default value is 100.
+     */
+    threshold: number;
+}
+/**
+ * Settings to configure the CullerRenderer.
+ */
+export declare class CullerRendererConfigManager extends Configurator<CullerRenderer, CullerRendererConfigType> {
+    protected _config: CullerRendererConfigType;
+    private _interval;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get autoUpdate(): boolean;
+    set autoUpdate(value: boolean);
+    get updateInterval(): number;
+    set updateInterval(value: number);
+    get renderDebugFrame(): boolean;
+    set renderDebugFrame(value: boolean);
+    get threshold(): number;
+    set threshold(value: number);
+    setWidthHeight(width: number, height: number): void;
+    setAutoAndInterval(auto: boolean, interval: number): void;
+    private resetRenderTarget;
+    private resetInterval;
+}
+export {};

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

@@ -1,35 +1,13 @@
 import * as THREE from "three";
 import { Components } from "../../Components";
-import { AsyncEvent, Event, World } from "../../Types";
-/**
- * Settings to configure the CullerRenderer.
- */
-export interface CullerRendererSettings {
-    /**
-     * Interval in milliseconds at which the visibility check should be performed.
-     * Default value is 1000.
-     */
-    updateInterval?: number;
-    /**
-     * Width of the render target used for visibility checks.
-     * Default value is 512.
-     */
-    width?: number;
-    /**
-     * Height of the render target used for visibility checks.
-     * Default value is 512.
-     */
-    height?: number;
-    /**
-     * Whether the visibility check should be performed automatically.
-     * Default value is true.
-     */
-    autoUpdate?: boolean;
-}
+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 {
+export declare class CullerRenderer implements Configurable<CullerRendererConfigManager, CullerRendererConfig> {
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
     /**
@@ -47,29 +25,36 @@ export declare class CullerRenderer {
      * You can bind this to the camera movement, to a certain interval, etc.
      */
     needsUpdate: boolean;
-    /**
-     * Render the internal scene used to determine the object visibility. Used
-     * for debugging purposes.
-     */
-    renderDebugFrame: 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 autoUpdate: boolean;
-    protected updateInterval: number;
+    protected _defaultConfig: CullerRendererConfig;
     protected readonly worker: Worker;
     protected readonly scene: THREE.Scene;
-    private _width;
-    private _height;
     private _availableColor;
-    private readonly renderTarget;
-    private readonly bufferSize;
-    private readonly _buffer;
     protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
+    constructor(components: Components, world: World);
     /** {@link Disposable.dispose} */
     dispose(): void;
     /**
@@ -79,6 +64,7 @@ export declare class CullerRenderer {
      * not true.
      */
     updateVisibility: (force?: boolean) => Promise<void>;
+    setup(config?: Partial<CullerRendererConfig>): void;
     protected getAvailableColor(): {
         r: number;
         g: number;
@@ -87,5 +73,4 @@ export declare class CullerRenderer {
     };
     protected increaseColor(): void;
     protected decreaseColor(): void;
-    private applySettings;
 }

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

@@ -1,5 +1,5 @@
 import * as THREE from "three";
-import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
+import { CullerRenderer } from "./culler-renderer";
 import { Components } from "../../Components";
 import { Event, World, Disposable } from "../../Types";
 /**
@@ -14,42 +14,36 @@ export declare class MeshCullerRenderer extends CullerRenderer implements Dispos
         seen: Set<THREE.Mesh>;
         unseen: Set<THREE.Mesh>;
     }>;
-    /**
-     * Pixels in screen a geometry must occupy to be considered "seen".
-     * Default value is 100.
-     */
-    threshold: number;
     /**
      * 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[]>>;
     /**
-     * Flag to indicate if the renderer is currently processing.
-     * Used to prevent concurrent processing.
+     * @deprecated use config.threshold instead.
+     */
+    get threshold(): number;
+    /**
+     * @deprecated use config.threshold instead.
      */
-    isProcessing: boolean;
-    private _interval;
+    set threshold(value: number);
     private _colorCodeMeshMap;
     private _meshIDColorCodeMap;
     private _currentVisibleMeshes;
     private _recentlyHiddenMeshes;
-    private _intervalID;
     private readonly _transparentMat;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
+    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.
-     * @returns {void}
      */
     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.
-     * @returns {void}
      */
     remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
     /**

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

@@ -1,5 +1,5 @@
 import { Component, Disposable, World, Event } from "../Types";
-import { GridConfig, SimpleGrid } from "./src";
+import { SimpleGrid } from "./src";
 import { Components } from "../Components";
 export * from "./src";
 /**
@@ -15,10 +15,6 @@ export declare class Grids extends Component implements Disposable {
      * A map of world UUIDs to their corresponding grid instances.
      */
     list: Map<string, SimpleGrid>;
-    /**
-     * The default configuration for grid creation.
-     */
-    config: Required<GridConfig>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
     /** {@link Component.enabled} */

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

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

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

@@ -0,0 +1,46 @@
+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 {
+    /**
+     * 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;
+    get visible(): boolean;
+    set visible(value: boolean);
+    get color(): THREE.Color;
+    set color(value: THREE.Color);
+    get primarySize(): number;
+    set primarySize(value: number);
+    get secondarySize(): number;
+    set secondarySize(value: number);
+    get distance(): number;
+    set distance(value: number);
+}
+export {};

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

@@ -1,37 +1,24 @@
 import * as THREE from "three";
-import { Hideable, Event, World, Disposable } from "../../Types";
+import { Hideable, Event, World, Disposable, Configurable } from "../../Types";
 import { Components } from "../../Components";
-/**
- * Configuration interface for the {@link SimpleGrid} class.
- */
-export interface GridConfig {
-    /**
-     * The color of the grid lines.
-     */
-    color: THREE.Color;
-    /**
-     * The size of the primary grid lines.
-     */
-    size1: number;
-    /**
-     * The size of the secondary grid lines.
-     */
-    size2: number;
-    /**
-     * The distance at which the grid lines start to fade away.
-     */
-    distance: number;
-}
+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 {
+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} */
@@ -51,7 +38,9 @@ export declare class SimpleGrid implements Hideable, Disposable {
     /** The Three.js mesh that contains the infinite grid. */
     readonly three: THREE.Mesh;
     private _fade;
-    constructor(components: Components, world: World, config: GridConfig);
+    constructor(components: Components, world: World);
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<SimpleGridConfig>): void;
     /** {@link Disposable.dispose} */
     dispose(): void;
     private setupEvents;

package/dist/core/Types/src/{config-manager.d.ts → config-types.d.ts}

@@ -5,7 +5,6 @@ export interface BooleanSettingsControl {
 }
 export interface ColorSettingsControl {
     type: "Color";
-    opacity: number;
     value: THREE.Color;
 }
 export interface TextSettingsControl {
@@ -21,30 +20,23 @@ export interface NumberSettingControl {
 }
 export interface SelectSettingControl {
     type: "Select";
+    multiple: boolean;
     options: Set<string>;
     value: string;
 }
-export interface MultiSelectSettingControl {
-    type: "MultiSelect";
-    options: Set<string>;
-    value: Set<string>;
-}
 export interface Vector3SettingControl {
-    type: "Vector";
+    type: "Vector3";
     value: THREE.Vector3;
 }
 export interface TextSetSettingControl {
     type: "TextSet";
     value: Set<string>;
 }
-type ControlEntry = BooleanSettingsControl | ColorSettingsControl | TextSettingsControl | NumberSettingControl | SelectSettingControl | Vector3SettingControl | TextSetSettingControl | MultiSelectSettingControl;
-interface ControlsSchema {
-    [name: string]: ControlEntry | ControlsSchema;
+export interface NoControl {
+    type: "None";
+    value: any;
 }
-export declare abstract class ConfigManager<T, U extends ControlsSchema> {
-    protected abstract _list: U;
-    protected _component: T;
-    get controls(): any;
-    constructor(component: T);
+export type ControlEntry = BooleanSettingsControl | ColorSettingsControl | TextSettingsControl | NumberSettingControl | SelectSettingControl | Vector3SettingControl | TextSetSettingControl | NoControl;
+export interface ControlsSchema {
+    [name: string]: ControlEntry | ControlsSchema;
 }
-export {};

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

@@ -11,4 +11,4 @@ export * from "./world";
 export * from "./data-set";
 export * from "./data-map";
 export * from "./component-with-ui";
-export * from "./config-manager";
+export * from "./config-types";

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

@@ -1,9 +1,9 @@
 import { World, Component, Disposable, Event, DataMap, Configurable } from "../Types";
 import { Components } from "../Components";
 import { BCFViewpoint, Viewpoint } from "./src";
-import { ViewpointsConfigManger, ViewpointsConfig } from "./src/viewpoints-config";
+import { ViewpointsConfigManager, ViewpointsConfig } from "./src/viewpoints-config";
 export * from "./src";
-export declare class Viewpoints extends Component implements Disposable, Configurable<ViewpointsConfigManger, ViewpointsConfig> {
+export declare class Viewpoints extends Component implements Disposable, Configurable<ViewpointsConfigManager, ViewpointsConfig> {
     static readonly uuid: "ee867824-a796-408d-8aa0-4e5962a83c66";
     enabled: boolean;
     /**
@@ -24,7 +24,7 @@ export declare class Viewpoints extends Component implements Disposable, Configu
     isSetup: boolean;
     setup(): void;
     onSetup: Event<unknown>;
-    config: ViewpointsConfigManger;
+    config: ViewpointsConfigManager;
     readonly onDisposed: Event<unknown>;
     /**
      * Disposes of the Viewpoints component and its associated resources.

package/dist/core/Viewpoints/src/viewpoints-config.d.ts

@@ -1,5 +1,6 @@
-import { BooleanSettingsControl, ConfigManager } from "../../Types";
+import { BooleanSettingsControl } from "../../Types";
 import { Viewpoints } from "../index";
+import { Configurator } from "../../ConfigManager";
 /**
  * Configuration interface for the Viewpoints general behavior.
  */
@@ -14,14 +15,8 @@ export interface ViewpointsConfig {
 type ViewpointsConfigType = {
     overwriteColors: BooleanSettingsControl;
 };
-export declare class ViewpointsConfigManger extends ConfigManager<Viewpoints, ViewpointsConfigType> {
-    protected _list: {
-        overwriteColors: {
-            value: boolean;
-            opacity: number;
-            type: "Boolean";
-        };
-    };
+export declare class ViewpointsConfigManager extends Configurator<Viewpoints, ViewpointsConfigType> {
+    protected _config: ViewpointsConfigType;
     get overwriteColors(): boolean;
     set overwriteColors(value: boolean);
 }

package/dist/core/Worlds/src/simple-scene-config.d.ts

@@ -1,6 +1,7 @@
 import * as THREE from "three";
 import { SimpleScene } from "./simple-scene";
-import { ColorSettingsControl, ConfigManager, NumberSettingControl, Vector3SettingControl } from "../../Types";
+import { ColorSettingsControl, NumberSettingControl, Vector3SettingControl } from "../../Types";
+import { Configurator } from "../../ConfigManager";
 type SimpleSceneConfigType = {
     backgroundColor: ColorSettingsControl;
     ambientLight: {
@@ -48,42 +49,8 @@ export interface SimpleSceneConfig {
         intensity: number;
     };
 }
-export declare class SimpleSceneConfigManager extends ConfigManager<SimpleScene, SimpleSceneConfigType> {
-    protected _list: {
-        backgroundColor: {
-            value: THREE.Color;
-            opacity: number;
-            type: "Color";
-        };
-        ambientLight: {
-            color: {
-                type: "Color";
-                opacity: number;
-                value: THREE.Color;
-            };
-            intensity: {
-                type: "Number";
-                interpolable: boolean;
-                value: number;
-            };
-        };
-        directionalLight: {
-            color: {
-                type: "Color";
-                opacity: number;
-                value: THREE.Color;
-            };
-            intensity: {
-                type: "Number";
-                interpolable: boolean;
-                value: number;
-            };
-            position: {
-                type: "Vector";
-                value: THREE.Vector3;
-            };
-        };
-    };
+export declare class SimpleSceneConfigManager extends Configurator<SimpleScene, SimpleSceneConfigType> {
+    protected _config: SimpleSceneConfigType;
     ambientLight: AmbientLightConfig;
     directionalLight: DirectionalLightConfig;
     get backgroundColor(): THREE.Color;