@woosh/meep-engine 2.165.5 → 2.165.7

package/src/engine/graphics/render/forward_plus/plugin/ForwardPlusRenderingPlugin.d.ts

@@ -1,5 +1,27 @@
-import {EnginePlugin} from "../../../../plugin/EnginePlugin";
-
-export class ForwardPlusRenderingPlugin extends EnginePlugin {
-    setClusterResolution(x: number, y: number, z: number): void
-}
+export class ForwardPlusRenderingPlugin extends EnginePlugin {
+    __light_manager: LightManager;
+    __resolution: ThreeVector2;
+    __material_transformer: MaterialTransformer;
+    /**
+     * Set resolution of the cluster texture, higher resolution will result in less load on the GPU, but will take up more RAM to represent and more time to build the clusters each frame
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    setClusterResolution(x: number, y: number, z: number): void;
+    /**
+     *
+     * @param {CameraView} view
+     * @private
+     */
+    private __prepare_for_render;
+    updateResolution(): void;
+    startup(): Promise<void>;
+    shutdown(): Promise<void>;
+    getLightManager(): LightManager;
+}
+import { EnginePlugin } from "../../../../plugin/EnginePlugin.js";
+import { LightManager } from "../LightManager.js";
+import { Vector2 as ThreeVector2 } from "three";
+import { MaterialTransformer } from "./MaterialTransformer.js";
+//# sourceMappingURL=ForwardPlusRenderingPlugin.d.ts.map

package/src/engine/graphics/render/forward_plus/plugin/MaterialTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MaterialTransformer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/plugin/MaterialTransformer.js"],"names":[],"mappings":"AAcA;IAEI;;;;OAIG;IACH,yDAuDC;IApDG,8BAAoC;IACpC,2BAA8B;IAEb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiChB;IAED,2CAaC;IAGL;;;OAGG;IACH,kCAWC;IAED,4BAiCC;CACJ;4CAjI2C,0DAA0D;wBAEvE,OAAO"}
+{"version":3,"file":"MaterialTransformer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/plugin/MaterialTransformer.js"],"names":[],"mappings":"AASA;IAEI;;;;OAIG;IACH,yDAuDC;IApDG,8BAAoC;IACpC,2BAA8B;IAEb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiChB;IAED,2CAaC;IAGL;;;OAGG;IACH,kCAWC;IAED,4BAiCC;CACJ;4CA5H2C,0DAA0D;wBAEvE,OAAO"}

package/src/engine/graphics/render/forward_plus/plugin/MaterialTransformer.js

@@ -5,12 +5,7 @@ import { isLitMaterial } from "./isLitMaterial.js";
 import { fp_build_fragment_shader } from "../materials/fp_build_fragment_shader.js";
 import { fp_build_vertex_shader } from "../materials/fp_build_vertex_shader.js";
 import { fp_build_vertex_lighting_shared } from "../materials/fp_build_vertex_lighting_shared.js";
-
-/**
- * @readonly
- * @type {string}
- */
-const PROPERTY_TRANSFORMER_MARKER = '@forward-plus-material-transformer';
+import { FORWARD_PLUS_MATERIAL_MARKER } from "./forwardPlusMaterialMarker.js";
 
 export class MaterialTransformer extends AbstractMaterialTransformer {
 
@@ -94,10 +89,10 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
     }
 
     transform(source) {
-        if (source.hasOwnProperty(PROPERTY_TRANSFORMER_MARKER)) {
+        if (source.hasOwnProperty(FORWARD_PLUS_MATERIAL_MARKER)) {
             // already transformed
 
-            if (source[PROPERTY_TRANSFORMER_MARKER] !== this) {
+            if (source[FORWARD_PLUS_MATERIAL_MARKER] !== this) {
                 throw new Error('The material is already transformed, but is associated with a different transformer instance');
             } else {
                 return source;
@@ -121,7 +116,7 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
             result.onBeforeCompile = composeCompile(source.onBeforeCompile, this.__on_before_compile);
 
 
-            result[PROPERTY_TRANSFORMER_MARKER] = this;
+            result[FORWARD_PLUS_MATERIAL_MARKER] = this;
 
         }
 

package/src/engine/graphics/render/forward_plus/plugin/forwardPlusMaterialMarker.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Whether `material` carries the Forward+ transformation marker, i.e. it has already
+ * been run through a {@link MaterialTransformer}.
+ * @param {Material} material
+ * @returns {boolean}
+ */
+export function isForwardPlusTransformed(material: Material): boolean;
+/**
+ * Property key stamped onto a material once a Forward+ {@link MaterialTransformer} has
+ * injected clustered-lighting / decal shader code into it. The value stored under the
+ * key is the transformer instance that performed the transformation.
+ * @readonly
+ * @type {string}
+ */
+export const FORWARD_PLUS_MATERIAL_MARKER: string;
+//# sourceMappingURL=forwardPlusMaterialMarker.d.ts.map

package/src/engine/graphics/render/forward_plus/plugin/forwardPlusMaterialMarker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forwardPlusMaterialMarker.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/plugin/forwardPlusMaterialMarker.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,8DAFa,OAAO,CAInB;AAjBD;;;;;;GAMG;AACH,2CAFU,MAAM,CAEiE"}

package/src/engine/graphics/render/forward_plus/plugin/forwardPlusMaterialMarker.js

@@ -0,0 +1,18 @@
+/**
+ * Property key stamped onto a material once a Forward+ {@link MaterialTransformer} has
+ * injected clustered-lighting / decal shader code into it. The value stored under the
+ * key is the transformer instance that performed the transformation.
+ * @readonly
+ * @type {string}
+ */
+export const FORWARD_PLUS_MATERIAL_MARKER = '@forward-plus-material-transformer';
+
+/**
+ * Whether `material` carries the Forward+ transformation marker, i.e. it has already
+ * been run through a {@link MaterialTransformer}.
+ * @param {Material} material
+ * @returns {boolean}
+ */
+export function isForwardPlusTransformed(material) {
+    return material.hasOwnProperty(FORWARD_PLUS_MATERIAL_MARKER);
+}

package/src/engine/graphics/render/forward_plus/plugin/isForwardPlusLightingSkipped.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Development diagnostic. Returns `true` when `material` will silently miss Forward+
+ * clustered lighting: Forward+ is active (a {@link MaterialTransformer} compile step is
+ * registered on the manager), the material is lit, yet it never went through
+ * transformation.
+ *
+ * Returns `false` when Forward+ is not installed, because lit materials are then
+ * legitimately untransformed — this keeps the check correct for engine configurations
+ * that do not use Forward+ rendering.
+ *
+ * @param {MaterialManager} material_manager
+ * @param {Material} material
+ * @returns {boolean}
+ */
+export function isForwardPlusLightingSkipped(material_manager: MaterialManager, material: Material): boolean;
+//# sourceMappingURL=isForwardPlusLightingSkipped.d.ts.map

package/src/engine/graphics/render/forward_plus/plugin/isForwardPlusLightingSkipped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isForwardPlusLightingSkipped.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/plugin/isForwardPlusLightingSkipped.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,qGAFa,OAAO,CAcnB"}

package/src/engine/graphics/render/forward_plus/plugin/isForwardPlusLightingSkipped.js

@@ -0,0 +1,31 @@
+import { isLitMaterial } from "./isLitMaterial.js";
+import { MaterialTransformer } from "./MaterialTransformer.js";
+import { isForwardPlusTransformed } from "./forwardPlusMaterialMarker.js";
+
+/**
+ * Development diagnostic. Returns `true` when `material` will silently miss Forward+
+ * clustered lighting: Forward+ is active (a {@link MaterialTransformer} compile step is
+ * registered on the manager), the material is lit, yet it never went through
+ * transformation.
+ *
+ * Returns `false` when Forward+ is not installed, because lit materials are then
+ * legitimately untransformed — this keeps the check correct for engine configurations
+ * that do not use Forward+ rendering.
+ *
+ * @param {MaterialManager} material_manager
+ * @param {Material} material
+ * @returns {boolean}
+ */
+export function isForwardPlusLightingSkipped(material_manager, material) {
+    if (!isLitMaterial(material)) {
+        // unlit materials are never transformed for clustered lighting
+        return false;
+    }
+
+    if (material_manager.getCompilationSteps(MaterialTransformer).length === 0) {
+        // Forward+ is not active, nothing is expected to transform lit materials
+        return false;
+    }
+
+    return !isForwardPlusTransformed(material);
+}

package/src/engine/graphics/render/frame_graph/FrameGraph.d.ts

@@ -54,7 +54,7 @@ export class FrameGraph {
      *
      * @type {Signal<IFrameGraphContext,this>}
      */
-    onExecuted: Signal<IFrameGraphContext, this>;
+    onExecuted: any;
     /**
      *
      * @type {FramePassNode[]}

package/src/engine/graphics/render/frame_graph/FrameGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FrameGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/frame_graph/FrameGraph.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IAmCI;;;OAGG;IACH,mBAFW,MAAM,EAOhB;IA3CD;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,6CAA0B;IAE1B;;;;OAIG;IACH,qBAAkB;IAElB;;;;OAIG;IACH,yBAAsB;IAEtB;;;;OAIG;IACH,4BAAyB;IAazB;;;;OAIG;IACH,qBAHW,MAAM,sBAehB;IAED;;;;OAIG;IACH,oBAHW,MAAM,qBAehB;IAED;;;;OAIG;IACH,qBAHW,MAAM,KAKhB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,oBAEJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,6BAYC;IAED;;;;;;OAMG;IACH,4BAeC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,MAAM,CAkBlB;IAED;;;;;;OAMG;IACH,2BALW,MAAM,wDAGJ,MAAM,CAUlB;IAED;;;OAGG;IACH,4BAHa,OAAO,CAQnB;IAED;;;;;;;OAOG;IACH,eALW,MAAM,4BAGJ,gBAAgB,CA2B5B;IAED;;;;;;OAMG;IACH,iEAFa,OAAO,CAQnB;IAED,gBA6FC;IAED;;;OAGG;IACH,2CAuDC;IAED;;;;;;;OAOG;IACH;gBAFqB,EAAE;mBAAa,EAAE;MA2DrC;IAED;;;;;OAKG;IACH,eAFY,MAAM,CA0GjB;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC;8BAxnB6B,oBAAoB;6BACrB,mBAAmB;iCAJf,uBAAuB"}
+{"version":3,"file":"FrameGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/frame_graph/FrameGraph.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IAmCI;;;OAGG;IACH,mBAFW,MAAM,EAOhB;IA3CD;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,gBAA0B;IAE1B;;;;OAIG;IACH,qBAAkB;IAElB;;;;OAIG;IACH,yBAAsB;IAEtB;;;;OAIG;IACH,4BAAyB;IAazB;;;;OAIG;IACH,qBAHW,MAAM,sBAehB;IAED;;;;OAIG;IACH,oBAHW,MAAM,qBAehB;IAED;;;;OAIG;IACH,qBAHW,MAAM,KAKhB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,oBAEJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,6BAYC;IAED;;;;;;OAMG;IACH,4BAeC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,MAAM,CAkBlB;IAED;;;;;;OAMG;IACH,2BALW,MAAM,wDAGJ,MAAM,CAUlB;IAED;;;OAGG;IACH,4BAHa,OAAO,CAQnB;IAED;;;;;;;OAOG;IACH,eALW,MAAM,4BAGJ,gBAAgB,CA2B5B;IAED;;;;;;OAMG;IACH,iEAFa,OAAO,CAQnB;IAED,gBA6FC;IAED;;;OAGG;IACH,2CAuDC;IAED;;;;;;;OAOG;IACH;gBAFqB,EAAE;mBAAa,EAAE;MA2DrC;IAED;;;;;OAKG;IACH,eAFY,MAAM,CA0GjB;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC;8BAxnB6B,oBAAoB;6BACrB,mBAAmB;iCAJf,uBAAuB"}

package/src/engine/graphics/render/frame_graph/resource/TextureResourceDescriptor.d.ts

@@ -2,7 +2,7 @@ export class TextureResourceDescriptor extends ResourceDescriptor {
     static from({ height, width, format, channel_count, initial_state }: {
         height?: number;
         width?: number;
-        format?: BinaryDataType;
+        format?: string;
         channel_count?: number;
         initial_state?: number;
     }): TextureResourceDescriptor;

package/src/engine/graphics/render/gizmo/Gizmo.d.ts

@@ -1,3 +1,7 @@
-import {GizmoShapeRenderingInterface} from "./GizmoShapeRenderingInterface";
-
-export const Gizmo: GizmoShapeRenderingInterface;
+/**
+ *
+ * @type {GizmoShapeRenderingInterface}
+ */
+export const Gizmo: GizmoShapeRenderingInterface;
+import { GizmoShapeRenderingInterface } from "./GizmoShapeRenderingInterface.js";
+//# sourceMappingURL=Gizmo.d.ts.map

package/src/engine/graphics/render/gizmo/GizmoRenderingPlugin.d.ts

@@ -1,5 +1,5 @@
-import {EnginePlugin} from "../../../plugin/EnginePlugin";
-
-export class GizmoRenderingPlugin extends EnginePlugin{
-    
-}
+export class GizmoRenderingPlugin extends EnginePlugin {
+    __layer: any;
+}
+import { EnginePlugin } from "../../../plugin/EnginePlugin.js";
+//# sourceMappingURL=GizmoRenderingPlugin.d.ts.map

package/src/engine/graphics/render/gizmo/GizmoRenderingPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GizmoRenderingPlugin.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/gizmo/GizmoRenderingPlugin.js"],"names":[],"mappings":"AAGA;IACI,wBAUC;IATG,aAA0D;IAW9D,yBAMC;CAEJ;6BAxB4B,iCAAiC"}
+{"version":3,"file":"GizmoRenderingPlugin.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/gizmo/GizmoRenderingPlugin.js"],"names":[],"mappings":"AAGA;IAEQ,aAA0D;CAmBjE;6BAxB4B,iCAAiC"}

package/src/engine/graphics/render/gizmo/GizmoShapeRenderingInterface.d.ts

@@ -1,13 +1,72 @@
-export class GizmoShapeRenderingInterface {
-    color: number[]
-
-    draw_solid_cube(center: number[], size: number[]): void
-
-    draw_wire_cube(center: number[], size: number[]): void
-
-    draw_solid_sphere(center: number[], radius: number): void
-
-    draw_wire_sphere(center: number[], radius: number): void
-
-    static INSTANCE: GizmoShapeRenderingInterface
-}
+/**
+ * Inspired by IMGUI and Unity's debug renderer
+ */
+export class GizmoShapeRenderingInterface {
+    /**
+     *
+     * @type {number[]|Float32Array}
+     * @private
+     */
+    private __color;
+    __boxes_solid: InstancedMeshGroup;
+    __boxes_wire: InstancedMeshGroup;
+    __sphere_solid: InstancedMeshGroup;
+    __sphere_wire: InstancedMeshGroup;
+    __lines: Lines;
+    __get_groups(): (InstancedMeshGroup | Lines)[];
+    /**
+     *
+     * @param {THREE.Object3D[]} destination
+     * @param {number} destination_offset
+     * @param {number[]} frustum
+     */
+    collect(destination: THREE.Object3D[], destination_offset: number, frustum: number[]): number;
+    clear(): void;
+    /**
+     * Color used for drawing shapes, draw_x will take on the currently set color when called
+     * RGBA
+     * @param {number[]} color
+     */
+    set color(arg: number[]);
+    /**
+     * RGBA
+     * @return {number[]}
+     */
+    get color(): number[];
+    /**
+     *
+     * @param {number[]} center
+     * @param {number[]} size
+     */
+    draw_solid_cube(center: number[], size: number[]): void;
+    /**
+     *
+     * @param {number[]} center
+     * @param {number[]} size
+     */
+    draw_wire_cube(center: number[], size: number[]): void;
+    /**
+     *
+     * @param {number[]} from
+     * @param {number[]} to
+     */
+    draw_line(from: number[], to: number[]): void;
+    /**
+     *
+     * @param {number[]} center
+     * @param {number} radius
+     */
+    draw_solid_sphere(center: number[], radius: number): void;
+    /**
+     *
+     * @param {number[]} center
+     * @param {number} radius
+     */
+    draw_wire_sphere(center: number[], radius: number): void;
+}
+export namespace GizmoShapeRenderingInterface {
+    let INSTANCE: GizmoShapeRenderingInterface;
+}
+import { InstancedMeshGroup } from "../../geometry/instancing/InstancedMeshGroup.js";
+import { Lines } from "../Lines.js";
+//# sourceMappingURL=GizmoShapeRenderingInterface.d.ts.map

package/src/engine/graphics/render/layers/RenderLayer.d.ts

@@ -1,22 +1,78 @@
-import {Object3D} from "three";
-import {IncrementalDeltaSet} from "../visibility/IncrementalDeltaSet";
-import {RenderLayerState} from "./RenderLayerState";
-
-export class RenderLayer {
-    name: string
-    state: RenderLayerState
-
-    managed: boolean
-
-    /**
-     * @deprecated
-     */
-    extractRenderable(leafData: any): Object3D
-
-    /**
-     * @deprecated
-     */
-    visibleSet: IncrementalDeltaSet<Object3D>
-
-    compute_depth_range: ((result: { near: number; far: number }, frustum: ArrayLike<number>, plane_normal_x: number, plane_normal_y: number, plane_normal_z: number, plane_constant: number) => void) | null
-}
+export class RenderLayer {
+    /**
+     *
+     * @type {RenderLayerState}
+     */
+    state: RenderLayerState;
+    /**
+     *
+     * @type {String|null}
+     */
+    name: string | null;
+    /**
+     * Layer is managed externally, visibility will not be updated in the rendering engine
+     * @deprecated
+     * @type {boolean}
+     */
+    managed: boolean;
+    /**
+     *
+     * @type {function(*): Object3D}
+     */
+    extractRenderable: (arg0: any) => Object3D;
+    /**
+     * @deprecated use CameraView's visible set instead
+     * Contains visible elements across all views, if element is in at least one view - it will be here
+     * @deprecated
+     * @type {IncrementalDeltaSet<THREE.Object3D>}
+     */
+    visibleSet: IncrementalDeltaSet<THREE.Object3D>;
+    /**
+     * @deprecated
+     * @param {boolean} v
+     */
+    set visible(arg: boolean);
+    /**
+     * @deprecated
+     * @returns {boolean}
+     */
+    get visible(): boolean;
+    /**
+     * Compute near and far clipping planes for a camera given a frustum.
+     * Note: near plane is frustum.planes[4], far plane is frustum.planes[5]
+     * @deprecated
+     * @param {Frustum} frustum
+     * @param {number} near
+     * @param {number} far
+     * @param {function(near:number, far:number)} callback
+     * @param [thisArg]
+     */
+    computeNearFarClippingPlanes(frustum: Frustum, near: number, far: number, callback: any, thisArg?: any): void;
+    /**
+     * @deprecated
+     * @param {THREE.Object3D[]} destination
+     * @param {number} destination_offset
+     * @param {CameraView} view
+     * @returns {number} Number of records added to destination
+     */
+    buildVisibleSet(destination: THREE.Object3D[], destination_offset: number, view: CameraView): number;
+    /**
+     * Expand a (near, far) depth range to cover this layer's content that
+     * intersects a frustum. Driven by the camera's autoClip path; defaults to
+     * a no-op for layers that don't own a BVH or don't participate in depth
+     * fitting (e.g. screen-space overlays).
+     *
+     * Systems with a BVH wire this from their `startup` alongside
+     * `buildVisibleSet` — typically using
+     * {@link bvh_query_depth_range_in_frustum} against their own BVH.
+     *
+     * @type {((result:{near:number,far:number}, frustum:ArrayLike<number>, plane_normal_x:number, plane_normal_y:number, plane_normal_z:number, plane_constant:number) => void) | null}
+     */
+    compute_depth_range: (result: {
+        near: number;
+        far: number;
+    }, frustum: ArrayLike<number>, plane_normal_x: number, plane_normal_y: number, plane_normal_z: number, plane_constant: number) => void;
+}
+import { RenderLayerState } from "./RenderLayerState.js";
+import { IncrementalDeltaSet } from "../visibility/IncrementalDeltaSet.js";
+//# sourceMappingURL=RenderLayer.d.ts.map

package/src/engine/graphics/render/layers/RenderLayerManager.d.ts

@@ -1,17 +1,72 @@
-import {RenderLayer} from "./RenderLayer";
-
-export class RenderLayerManager {
-    traverse(visitor: (layer: RenderLayer) => void, thisArg?: any): void
-
-    create(name: string): RenderLayer
-
-    add(layer: RenderLayer)
-
-    remove(layer: RenderLayer): boolean
-
-    getLayerByName(name: string): RenderLayer | undefined
-
-    getLayerCount(): number
-
-    getLayerByIndex(index: number): RenderLayer
-}
+export class RenderLayerManager {
+    /**
+     * @private
+     * @type {Stack<RenderLayerManagerState>}
+     */
+    private __stateStack;
+    /**
+     *
+     * @type {List<RenderLayer>}
+     */
+    layers: List<RenderLayer>;
+    /**
+     *
+     * @returns {number}
+     */
+    getLayerCount(): number;
+    /**
+     *
+     * @param {number} i
+     * @returns {RenderLayer}
+     */
+    getLayerByIndex(i: number): RenderLayer;
+    /**
+     * Hide all layers
+     */
+    hideAll(): void;
+    /**
+     *
+     * @returns {RenderLayerManagerState}
+     */
+    pushState(): RenderLayerManagerState;
+    popState(): void;
+    /**
+     *
+     * @param {string} name
+     * @return {RenderLayer}
+     */
+    create(name: string): RenderLayer;
+    /**
+     *
+     * @param {RenderLayer} layer
+     */
+    add(layer: RenderLayer): void;
+    /**
+     *
+     * @param {RenderLayer} layer
+     * @returns {boolean}
+     */
+    remove(layer: RenderLayer): boolean;
+    /**
+     *
+     * @param {string} name
+     * @returns {RenderLayer|undefined}
+     */
+    getLayerByName(name: string): RenderLayer | undefined;
+    /**
+     *
+     * @param {function(RenderLayer)} visitor
+     * @param {*} [thisArg]
+     */
+    traverse(visitor: (arg0: RenderLayer) => any, thisArg?: any): void;
+    /**
+     * @template {T}
+     * @param {function(RenderLayer):T} mapper
+     * @returns {T[]}
+     */
+    map(mapper: (arg0: RenderLayer) => T): T[];
+}
+import List from "../../../../core/collection/list/List.js";
+import { RenderLayer } from "./RenderLayer.js";
+import { RenderLayerManagerState } from "./RenderLayerManagerState.js";
+//# sourceMappingURL=RenderLayerManager.d.ts.map

package/src/engine/graphics/render/layers/RenderLayerState.d.ts

@@ -1,3 +1,18 @@
-export class RenderLayerState {
-    visible: boolean
-}
+export class RenderLayerState {
+    /**
+     * Whether the layer should be rendered or not
+     * @type {boolean}
+     */
+    visible: boolean;
+    /**
+     *
+     * @param {RenderLayerState} other
+     */
+    copy(other: RenderLayerState): void;
+    /**
+     *
+     * @returns {RenderLayerState}
+     */
+    clone(): RenderLayerState;
+}
+//# sourceMappingURL=RenderLayerState.d.ts.map

package/src/engine/graphics/render/view/CameraView.d.ts

@@ -38,9 +38,9 @@ export class CameraView {
      */
     flags: number;
     on: {
-        preVisibilityBuild: Signal<any, any, any, any, any, any, any, any>;
-        postVisibilityBuild: Signal<any, any, any, any, any, any, any, any>;
-        preRender: Signal<any, any, any, any, any, any, any, any>;
+        preVisibilityBuild: Signal;
+        postVisibilityBuild: Signal;
+        preRender: Signal;
     };
     /**
      *

package/src/engine/graphics/render/view/CameraViewManager.d.ts

@@ -12,8 +12,8 @@ export class CameraViewManager {
      */
     private __visibility_computer;
     on: {
-        preViewBuild: Signal<any, any, any, any, any, any, any, any>;
-        postViewBuild: Signal<any, any, any, any, any, any, any, any>;
+        preViewBuild: Signal;
+        postViewBuild: Signal;
     };
     /**
      *