@woosh/meep-engine 2.119.80 → 2.119.82

package/editor/ecs/component/editors/ecs/ParameterLookupTableEditor.d.ts

@@ -0,0 +1,67 @@
+export class ParameterLookupTableEditor extends TypeEditor<any> {
+    constructor();
+    get schema(): {
+        properties: {
+            on: {
+                transient: boolean;
+            };
+        };
+    };
+    build(parent: any, field: any, registry: any): CanvasView | EmptyView;
+    /**
+     * converts rgb to hex string
+     * @param {Float} r
+     * @param {Float} g
+     * @param {Float} b
+     */
+    RGBToHex(r: Float, g: Float, b: Float): string;
+    /**
+     * converts lut color sample to RGB
+     * @param {number[]} sample
+     */
+    convertRGB(sample: number[]): void;
+    /**
+     * draws tiled background
+     * @param {CanvasView} canvasView
+     * @param {CanvasRenderingContext2D} ctx
+     * @param {{}} config
+     */
+    DrawBackground(canvasView: CanvasView, ctx: CanvasRenderingContext2D, config: {}): void;
+    /**
+     * draws gradient
+     * @param {CanvasView} canvasView
+     * @param {ParameterLookupTable} lut
+     * @param {CanvasRenderingContext2D} ctx
+     * @param {{}} config
+     */
+    DrawGradient(canvasView: CanvasView, lut: ParameterLookupTable, ctx: CanvasRenderingContext2D, config: {}): void;
+    /**
+     * draws gradient stops
+     * @param {CanvasView} canvasView
+     * @param {ParameterLookupTable} lut
+     * @param {CanvasRenderingContext2D} ctx
+     * @param {EmptyView} colorView
+     * @param {{}} config
+     * @param {Integer} selectedInd
+     * @returns {*[]}
+     */
+    DrawStops(canvasView: CanvasView, lut: ParameterLookupTable, ctx: CanvasRenderingContext2D, colorView: EmptyView, config: {}, selectedInd: Integer): any[];
+    /**
+     * draws gradient stop
+     * @param {CanvasRenderingContext2D} ctx
+     * @param {Object} config
+     * @param {Integer} posX
+     * @param {Boolean} isSelected
+     */
+    DrawStop(ctx: CanvasRenderingContext2D, config: any, posX: Integer, isSelected: boolean): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        posX: Integer;
+    };
+}
+import { TypeEditor } from "../../TypeEditor.js";
+import { CanvasView } from "../../../../../src/view/elements/CanvasView.js";
+import EmptyView from "../../../../../src/view/elements/EmptyView.js";
+//# sourceMappingURL=ParameterLookupTableEditor.d.ts.map

package/editor/ecs/component/editors/ecs/ParameterLookupTableEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParameterLookupTableEditor.d.ts","sourceRoot":"","sources":["ParameterLookupTableEditor.js"],"names":[],"mappings":"AAOA;;IACI;;;;;;MAQC;IAED,sEA2FC;IAED;;;;;OAKG;IACH,+CAaC;IAED;;;OAGG;IACH,mBAFW,MAAM,EAAE,QAMlB;IAED;;;;;OAKG;IACH,2BAJW,UAAU,OACV,wBAAwB,UACxB,EAAE,QASZ;IAED;;;;;;OAMG;IACH,yBALW,UAAU,kCAEV,wBAAwB,UACxB,EAAE,QAaZ;IAED;;;;;;;;;OASG;IACH,sBARW,UAAU,kCAEV,wBAAwB,aACxB,SAAS,UACT,EAAE,yBAEA,KAAG,CAkBf;IAED;;;;;;OAMG;IACH,cALW,wBAAwB;;;;;;MA8BlC;CACJ;2BAzO0B,qBAAqB;2BAFrB,gDAAgD;sBACrD,+CAA+C"}

package/editor/ecs/component/editors/ecs/ParameterTrackEditor.d.ts

@@ -0,0 +1,12 @@
+export class ParameterTrackEditor extends ObjectEditor {
+    get schema(): {
+        properties: {
+            name: {
+                editor: EnumEditor;
+            };
+        };
+    };
+}
+import { ObjectEditor } from "../primitive/ObjectEditor.js";
+import { EnumEditor } from "../common/EnumEditor.js";
+//# sourceMappingURL=ParameterTrackEditor.d.ts.map

package/editor/ecs/component/editors/ecs/ParameterTrackEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParameterTrackEditor.d.ts","sourceRoot":"","sources":["ParameterTrackEditor.js"],"names":[],"mappings":"AAGA;IACI;;;;;;MAWC;CACJ;6BAhB4B,8BAA8B;2BAChC,yBAAyB"}

package/editor/ecs/component/editors/ecs/ParticleEmitterEditor.d.ts

@@ -0,0 +1,52 @@
+export class ParticleEmitterEditor extends ObjectEditor {
+    get schema(): {
+        properties: {
+            parameters: {
+                transient: boolean;
+            };
+            layers: {
+                type: typeof List;
+                type_parameters: (typeof ParticleLayer)[];
+            };
+            particles: {
+                transient: boolean;
+            };
+            mesh: {
+                transient: boolean;
+            };
+            bvhLeaf: {
+                transient: boolean;
+            };
+            particleBounds: {
+                transient: boolean;
+            };
+            emisionBounds: {
+                transient: boolean;
+            };
+            flags: {
+                editor: BitFlagsEditor;
+            };
+            blendingMode: {
+                editor: EnumEditor;
+            };
+            sleepTime: {
+                transient: boolean;
+            };
+            position: {
+                transient: boolean;
+            };
+            rotation: {
+                transient: boolean;
+            };
+            scale: {
+                transient: boolean;
+            };
+        };
+    };
+}
+import { ObjectEditor } from "../primitive/ObjectEditor.js";
+import List from "../../../../../src/core/collection/list/List.js";
+import { ParticleLayer } from "../../../../../src/engine/graphics/particles/particular/engine/emitter/ParticleLayer.js";
+import { BitFlagsEditor } from "../common/BitFlagsEditor.js";
+import { EnumEditor } from "../common/EnumEditor.js";
+//# sourceMappingURL=ParticleEmitterEditor.d.ts.map

package/editor/ecs/component/editors/ecs/ParticleEmitterEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleEmitterEditor.d.ts","sourceRoot":"","sources":["ParticleEmitterEditor.js"],"names":[],"mappings":"AAUA;IACI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6CC;CACJ;6BAnD4B,8BAA8B;iBAN1C,iDAAiD;8BACpC,yFAAyF;+BACxF,6BAA6B;2BAKjC,yBAAyB"}

package/editor/ecs/component/editors/ecs/ParticleEmitterLayerEditor.d.ts

@@ -0,0 +1,48 @@
+export class ParticleEmitterLayerEditor extends ObjectEditor {
+    get schema(): {
+        properties: {
+            imageURL: {
+                type: StringConstructor;
+                editor: ImagePathEditor;
+            };
+            emissionShape: {
+                editor: EnumEditor;
+            };
+            emissionFrom: {
+                editor: EnumEditor;
+            };
+            emissionRate: {
+                type: NumberConstructor;
+                numeric_type: BinaryDataType;
+            };
+            emissionImmediate: {
+                type: NumberConstructor;
+                numeric_type: BinaryDataType;
+            };
+            parameterTracks: {
+                editor: ParameterTrackSetEditor;
+            };
+            scaledSpriteHalfSize: {
+                transient: boolean;
+            };
+            baseBoundingBox: {
+                transient: boolean;
+            };
+            steps: {
+                type: typeof List;
+                type_parameters: (typeof SimulationStepDefinition)[];
+            };
+            timeSinceLastEmission: {
+                transient: boolean;
+            };
+        };
+    };
+}
+import { ObjectEditor } from "../primitive/ObjectEditor.js";
+import { ImagePathEditor } from "../ImagePathEditor.js";
+import { EnumEditor } from "../common/EnumEditor.js";
+import { BinaryDataType } from "../../../../../src/core/binary/type/BinaryDataType.js";
+import { ParameterTrackSetEditor } from "./ParameterTrackSetEditor.js";
+import List from "../../../../../src/core/collection/list/List.js";
+import { SimulationStepDefinition } from "../../../../../src/engine/graphics/particles/particular/engine/simulator/SimulationStepDefinition.js";
+//# sourceMappingURL=ParticleEmitterLayerEditor.d.ts.map

package/editor/ecs/component/editors/ecs/ParticleEmitterLayerEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleEmitterLayerEditor.d.ts","sourceRoot":"","sources":["ParticleEmitterLayerEditor.js"],"names":[],"mappings":"AAgBA;IACI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuCC;CACJ;6BArD4B,8BAA8B;gCAC3B,uBAAuB;2BAC5B,yBAAyB;+BAOrB,uDAAuD;wCAC9C,8BAA8B;iBAdrD,iDAAiD;yCAG3D,sGAAsG"}

package/editor/ecs/component/editors/ecs/SimulationStepDefinitionEditor.d.ts

@@ -0,0 +1,16 @@
+export class SimulationStepDefinitionEditor extends ObjectEditor {
+    get schema(): {
+        properties: {
+            type: {
+                editor: EnumEditor;
+            };
+            parameters: {
+                type: ArrayConstructor;
+                type_parameters: NumberConstructor[];
+            };
+        };
+    };
+}
+import { ObjectEditor } from "../primitive/ObjectEditor.js";
+import { EnumEditor } from "../common/EnumEditor.js";
+//# sourceMappingURL=SimulationStepDefinitionEditor.d.ts.map

package/editor/ecs/component/editors/ecs/SimulationStepDefinitionEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimulationStepDefinitionEditor.d.ts","sourceRoot":"","sources":["SimulationStepDefinitionEditor.js"],"names":[],"mappings":"AAMA;IACI;;;;;;;;;;MAYC;CACJ;6BApB4B,8BAA8B;2BAChC,yBAAyB"}

package/editor/ecs/component/editors/ecs/Trail2DEditor.d.ts

@@ -0,0 +1,30 @@
+export class Trail2DEditor extends ObjectEditor {
+    get schema(): {
+        properties: {
+            maxAge: {
+                description: string;
+            };
+            time: {
+                transient: boolean;
+            };
+            trailingIndex: {
+                transient: boolean;
+            };
+            timeSinceLastUpdate: {
+                transient: boolean;
+            };
+            ribbon: {
+                transient: boolean;
+            };
+            bvhLeaf: {
+                transient: boolean;
+            };
+            flags: {
+                editor: BitFlagsEditor;
+            };
+        };
+    };
+}
+import { ObjectEditor } from "../primitive/ObjectEditor.js";
+import { BitFlagsEditor } from "../common/BitFlagsEditor.js";
+//# sourceMappingURL=Trail2DEditor.d.ts.map

package/editor/ecs/component/editors/ecs/Trail2DEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Trail2DEditor.d.ts","sourceRoot":"","sources":["Trail2DEditor.js"],"names":[],"mappings":"AAIA;IACI;;;;;;;;;;;;;;;;;;;;;;;;MA0BC;CACJ;6BA9B4B,8BAA8B;+BAD5B,6BAA6B"}

package/editor/ecs/component/editors/ecs/TransformEditor.d.ts

@@ -0,0 +1,20 @@
+export class TransformEditor extends ObjectEditor {
+    get schema(): {
+        additionalProperties: boolean;
+        properties: {
+            position: {
+                type: typeof Vector3;
+            };
+            rotation: {
+                type: typeof Quaternion;
+            };
+            scale: {
+                type: typeof Vector3;
+            };
+        };
+    };
+}
+import { ObjectEditor } from "../primitive/ObjectEditor.js";
+import Vector3 from "../../../../../src/core/geom/Vector3.js";
+import Quaternion from "../../../../../src/core/geom/Quaternion.js";
+//# sourceMappingURL=TransformEditor.d.ts.map

package/editor/ecs/component/editors/ecs/TransformEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformEditor.d.ts","sourceRoot":"","sources":["TransformEditor.js"],"names":[],"mappings":"AAIA;IACI;;;;;;;;;;;;;MAgBC;CACJ;6BApB4B,8BAA8B;oBAFvC,yCAAyC;uBACtC,4CAA4C"}

package/editor/ecs/component/editors/ecs/terrain/SplatMappingEditor.d.ts

@@ -0,0 +1,19 @@
+export class SplatMappingEditor extends ObjectEditor {
+    get schema(): {
+        properties: {
+            depth: {
+                transient: boolean;
+            };
+            materialTexture: {
+                transient: boolean;
+                deprecated: boolean;
+            };
+            materialSampler: {
+                transient: boolean;
+                deprecated: boolean;
+            };
+        };
+    };
+}
+import { ObjectEditor } from "../../primitive/ObjectEditor.js";
+//# sourceMappingURL=SplatMappingEditor.d.ts.map

package/editor/ecs/component/editors/ecs/terrain/SplatMappingEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SplatMappingEditor.d.ts","sourceRoot":"","sources":["SplatMappingEditor.js"],"names":[],"mappings":"AAEA;IACI;;;;;;;;;;;;;;MAgBC;CACJ;6BApB4B,iCAAiC"}

package/editor/ecs/component/editors/ecs/terrain/TerrainEditor.d.ts

@@ -0,0 +1,39 @@
+export class TerrainEditor extends ObjectEditor {
+    get schema(): {
+        properties: {
+            id: {
+                transient: boolean;
+            };
+            flags: {
+                editor: BitFlagsEditor;
+                transient: boolean;
+            };
+            gridTransformKind: {
+                editor: EnumEditor;
+            };
+            material: {
+                transient: boolean;
+            };
+            heightRange: {
+                deprecated: boolean;
+            };
+            bvh: {
+                transient: boolean;
+            };
+            heightTexture: {
+                transient: boolean;
+            };
+            buildLightMap: {
+                type: FunctionConstructor;
+            };
+            aoMap: {
+                type: typeof Texture;
+            };
+        };
+    };
+}
+import { ObjectEditor } from "../../primitive/ObjectEditor.js";
+import { BitFlagsEditor } from "../../common/BitFlagsEditor.js";
+import { EnumEditor } from "../../common/EnumEditor.js";
+import { Texture } from "three";
+//# sourceMappingURL=TerrainEditor.d.ts.map

package/editor/ecs/component/editors/ecs/terrain/TerrainEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerrainEditor.d.ts","sourceRoot":"","sources":["TerrainEditor.js"],"names":[],"mappings":"AAOA;IA+CI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiCC;CACJ;6BAnF4B,iCAAiC;+BAF/B,gCAAgC;2BACpC,4BAA4B;wBAJ/B,OAAO"}

package/editor/ecs/component/editors/ecs/terrain/TerrainLayerEditor.d.ts

@@ -0,0 +1,16 @@
+export class TerrainLayerEditor extends ObjectEditor {
+    get schema(): {
+        properties: {
+            textureDiffuseURL: {
+                type: StringConstructor;
+                editor: ImagePathEditor;
+            };
+            diffuse: {
+                transient: boolean;
+            };
+        };
+    };
+}
+import { ObjectEditor } from "../../primitive/ObjectEditor.js";
+import { ImagePathEditor } from "../../ImagePathEditor.js";
+//# sourceMappingURL=TerrainLayerEditor.d.ts.map

package/editor/ecs/component/editors/ecs/terrain/TerrainLayerEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerrainLayerEditor.d.ts","sourceRoot":"","sources":["TerrainLayerEditor.js"],"names":[],"mappings":"AAGA;IACI;;;;;;;;;;MAYC;CACJ;6BAjB4B,iCAAiC;gCAC9B,0BAA0B"}

package/editor/ecs/component/editors/ecs/terrain/TerrainLayersEditor.d.ts

@@ -0,0 +1,19 @@
+export class TerrainLayersEditor extends ObjectEditor {
+    get schema(): {
+        additionalProperties: boolean;
+        properties: {
+            resolution: {
+                type: typeof Vector2;
+            };
+            layers: {
+                type: typeof List;
+                type_parameters: (typeof TerrainLayer)[];
+            };
+        };
+    };
+}
+import { ObjectEditor } from "../../primitive/ObjectEditor.js";
+import Vector2 from "../../../../../../src/core/geom/Vector2.js";
+import List from "../../../../../../src/core/collection/list/List.js";
+import { TerrainLayer } from "../../../../../../src/engine/ecs/terrain/ecs/layers/TerrainLayer.js";
+//# sourceMappingURL=TerrainLayersEditor.d.ts.map

package/editor/ecs/component/editors/ecs/terrain/TerrainLayersEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerrainLayersEditor.d.ts","sourceRoot":"","sources":["TerrainLayersEditor.js"],"names":[],"mappings":"AAKA;IACI;;;;;;;;;;;MAcC;CACJ;6BArB4B,iCAAiC;oBAG1C,4CAA4C;iBAF/C,oDAAoD;6BACxC,qEAAqE"}

package/editor/ecs/component/editors/ecs/terrain/TerrainOverlayEditor.d.ts

@@ -0,0 +1,18 @@
+export class TerrainOverlayEditor extends ObjectEditor {
+    get schema(): {
+        properties: {
+            tileImage: {
+                editor: ImagePathEditor;
+            };
+            fillColor: {
+                transient: boolean;
+            };
+            texture: {
+                transient: boolean;
+            };
+        };
+    };
+}
+import { ObjectEditor } from "../../primitive/ObjectEditor.js";
+import { ImagePathEditor } from "../../ImagePathEditor.js";
+//# sourceMappingURL=TerrainOverlayEditor.d.ts.map

package/editor/ecs/component/editors/ecs/terrain/TerrainOverlayEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerrainOverlayEditor.d.ts","sourceRoot":"","sources":["TerrainOverlayEditor.js"],"names":[],"mappings":"AAGA;IACI;;;;;;;;;;;;MAcC;CACJ;6BAnB4B,iCAAiC;gCAC9B,0BAA0B"}

package/editor/ecs/component/editors/three/BufferGeometryEditor.d.ts

@@ -0,0 +1,7 @@
+export class BufferGeometryEditor extends TypeEditor<any> {
+    constructor();
+    build(parent: any, field: any, registry: any): CanvasView;
+}
+import { TypeEditor } from "../../TypeEditor.js";
+import { CanvasView } from "../../../../../src/view/elements/CanvasView.js";
+//# sourceMappingURL=BufferGeometryEditor.d.ts.map

package/editor/ecs/component/editors/three/BufferGeometryEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BufferGeometryEditor.d.ts","sourceRoot":"","sources":["BufferGeometryEditor.js"],"names":[],"mappings":"AAQA;;IACI,0DAiBC;CACJ;2BArB0B,qBAAqB;2BADrB,gDAAgD"}

package/editor/ecs/component/editors/three/MaterialEditor.d.ts

@@ -0,0 +1,7 @@
+export class MaterialEditor extends TypeEditor<any> {
+    constructor();
+    build(parent: any, field: any, registry: any): CanvasView;
+}
+import { TypeEditor } from "../../TypeEditor.js";
+import { CanvasView } from "../../../../../src/view/elements/CanvasView.js";
+//# sourceMappingURL=MaterialEditor.d.ts.map

package/editor/ecs/component/editors/three/MaterialEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MaterialEditor.d.ts","sourceRoot":"","sources":["MaterialEditor.js"],"names":[],"mappings":"AAOA;;IACI,0DAiBC;CACJ;2BArB0B,qBAAqB;2BADrB,gDAAgD"}

package/editor/ecs/component/editors/three/MeshEditor.d.ts

@@ -0,0 +1,7 @@
+export class MeshEditor extends TypeEditor<any> {
+    constructor();
+    build(parent: any, field: any, registry: any): CanvasView;
+}
+import { TypeEditor } from "../../TypeEditor.js";
+import { CanvasView } from "../../../../../src/view/elements/CanvasView.js";
+//# sourceMappingURL=MeshEditor.d.ts.map

package/editor/ecs/component/editors/three/MeshEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeshEditor.d.ts","sourceRoot":"","sources":["MeshEditor.js"],"names":[],"mappings":"AAQA;;IACI,0DAwBC;CACJ;2BA5B0B,qBAAqB;2BADrB,gDAAgD"}

package/editor/ecs/component/editors/three/TextureEditor.d.ts

@@ -0,0 +1,7 @@
+export class TextureEditor extends TypeEditor<any> {
+    constructor();
+    build(parent: any, field: any, registry: any): EmptyView;
+}
+import { TypeEditor } from "../../TypeEditor.js";
+import EmptyView from "../../../../../src/view/elements/EmptyView.js";
+//# sourceMappingURL=TextureEditor.d.ts.map

package/editor/ecs/component/editors/three/TextureEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextureEditor.d.ts","sourceRoot":"","sources":["TextureEditor.js"],"names":[],"mappings":"AAcA;;IAGI,yDA6FC;CACJ;2BArG0B,qBAAqB;sBAD1B,+CAA+C"}

package/editor/process/DisableGameUIProcess.d.ts

@@ -0,0 +1,8 @@
+export class DisableGameUIProcess extends EditorProcess {
+    initialize(editor: any): void;
+}
+export namespace DisableGameUIProcess {
+    let Id: string;
+}
+import { EditorProcess } from "./EditorProcess.js";
+//# sourceMappingURL=DisableGameUIProcess.d.ts.map

package/editor/process/DisableGameUIProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DisableGameUIProcess.d.ts","sourceRoot":"","sources":["DisableGameUIProcess.js"],"names":[],"mappings":"AAGA;IAQI,8BAEC;CAyBJ;;;;8BAtC6B,oBAAoB"}

package/editor/process/ObstacleGridDisplayProcess.d.ts

@@ -0,0 +1,13 @@
+export class ObstacleGridDisplayProcess extends EditorProcess {
+    /**
+     *
+     * @type {TerrainOverlay|null}
+     */
+    overlay: TerrainOverlay | null;
+    draw(): void;
+}
+export namespace ObstacleGridDisplayProcess {
+    let Id: string;
+}
+import { EditorProcess } from "./EditorProcess.js";
+//# sourceMappingURL=ObstacleGridDisplayProcess.d.ts.map

package/editor/process/ObstacleGridDisplayProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObstacleGridDisplayProcess.d.ts","sourceRoot":"","sources":["ObstacleGridDisplayProcess.js"],"names":[],"mappings":"AAMA;IAIQ;;;OAGG;IACH,SAFU,iBAAe,IAAI,CAEV;IA4BvB,aAgEC;CASJ;;;;8BAnH6B,oBAAoB"}

package/editor/process/SymbolicDisplayProcess.d.ts

@@ -0,0 +1,19 @@
+export class SymbolicDisplayProcess extends EditorProcess {
+    requiredSystems: {
+        klass: typeof RenderSystem;
+        factory: () => RenderSystem;
+    }[];
+    /**
+     *
+     * @type {EditorProcess[]}
+     */
+    displays: EditorProcess[];
+    spawnedSystems: any[];
+    initialize(editor: any): void;
+}
+export namespace SymbolicDisplayProcess {
+    let Id: string;
+}
+import { EditorProcess } from "./EditorProcess.js";
+import RenderSystem from "../../src/engine/ecs/renderable/RenderSystem.js";
+//# sourceMappingURL=SymbolicDisplayProcess.d.ts.map

package/editor/process/SymbolicDisplayProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SymbolicDisplayProcess.d.ts","sourceRoot":"","sources":["SymbolicDisplayProcess.js"],"names":[],"mappings":"AAkBA;IAOQ;;;QAKE;IAEF;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEP;IAElB,sBAAwB;IAG5B,8BA2BC;CA2DJ;;;;8BA/H6B,oBAAoB;yBAEzB,iDAAiD"}

package/editor/process/symbolic/ComponentSymbolicDisplay.d.ts

@@ -0,0 +1,11 @@
+export class ComponentSymbolicDisplay extends EditorProcess {
+    constructor(components: any, creator: any, destructor: any);
+    /**
+     *
+     * @type {EntityObserver}
+     */
+    observer: EntityObserver;
+}
+import { EditorProcess } from "../EditorProcess.js";
+import { EntityObserver } from "../../../src/engine/ecs/EntityObserver.js";
+//# sourceMappingURL=ComponentSymbolicDisplay.d.ts.map

package/editor/process/symbolic/ComponentSymbolicDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentSymbolicDisplay.d.ts","sourceRoot":"","sources":["ComponentSymbolicDisplay.js"],"names":[],"mappings":"AAGA;IACI,4DAQC;IALG;;;OAGG;IACH,UAFU,cAAc,CAE2C;CAsB1E;8BAjC6B,qBAAqB;+BACpB,2CAA2C"}

package/editor/process/symbolic/SymbolicDisplayInternalAPI.d.ts

@@ -0,0 +1,65 @@
+export class SymbolicDisplayInternalAPI {
+    /**
+     *
+     * @type {SignalBinding[]}
+     */
+    bindings: SignalBinding[];
+    /**
+     *
+     * @type {Engine}
+     * @private
+     */
+    private __engine;
+    __requestUpdate: Signal<any, any, any, any, any, any, any, any>;
+    random: () => number;
+    /**
+     *
+     * @type {List<Entity>}
+     * @private
+     */
+    private __managed_entities;
+    /**
+     *
+     * @type {ProcessState}
+     * @private
+     */
+    private __state;
+    /**
+     *
+     * @type {EntityComponentDataset}
+     * @private
+     */
+    private __dataset;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __source_entity;
+    /**
+     *
+     * @param {Entity} entity
+     */
+    emit(entity: Entity): void;
+    /**
+     *
+     * @param {number} entity
+     * @param {EntityComponentDataset} ecd
+     * @param {Engine} engine
+     */
+    initialize({ entity, ecd, engine }: number): void;
+    finalize(): void;
+    /**
+     *
+     * @param {Transform} source
+     * @param {Transform} target
+     */
+    bindTransform(source: Transform, target: Transform): void;
+    bind(signal: any, action: any, context: any): void;
+    onFrame(method: any, thisArg: any): void;
+    unbind(signal: any, action: any, context: any): boolean;
+    update(): void;
+}
+import { SignalBinding } from "../../../src/core/events/signal/SignalBinding.js";
+import Signal from "../../../src/core/events/signal/Signal.js";
+//# sourceMappingURL=SymbolicDisplayInternalAPI.d.ts.map

package/editor/process/symbolic/SymbolicDisplayInternalAPI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SymbolicDisplayInternalAPI.d.ts","sourceRoot":"","sources":["SymbolicDisplayInternalAPI.js"],"names":[],"mappings":"AAQA;IAEQ;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEP;IAElB;;;;OAIG;IACH,iBAAoB;IAEpB,gEAAmC;IAEnC,qBAA8B;IAE9B;;;;OAIG;IACH,2BAAoC;IAEpC;;;;OAIG;IACH,gBAA+B;IAE/B;;;;OAIG;IACH,kBAAqB;IAErB;;;;OAIG;IACH,wBAAyB;IAG7B;;;OAGG;IACH,2BAaC;IAED;;;;;OAKG;IACH,oCAJW,MAAM,QAchB;IAED,iBAWC;IAED;;;;OAIG;IACH,0DAWC;IAED,mDAIC;IAED,yCAGC;IAED,wDAgBC;IAGD,eAEC;CAEJ;8BA9J6B,kDAAkD;mBAC7D,2CAA2C"}

package/editor/process/symbolic/buildThreeJSHelperEntity.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {Object3D} helper
+ * @param {number} sourceEntity
+ * @return {Entity}
+ */
+export function buildThreeJSHelperEntity(helper: Object3D, sourceEntity?: number): Entity;
+import Entity from "../../../src/engine/ecs/Entity.js";
+//# sourceMappingURL=buildThreeJSHelperEntity.d.ts.map

package/editor/process/symbolic/buildThreeJSHelperEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildThreeJSHelperEntity.d.ts","sourceRoot":"","sources":["buildThreeJSHelperEntity.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,0EAHW,MAAM,GACL,MAAM,CAwBjB;mBAnCkB,mCAAmC"}

package/editor/process/symbolic/make3DSymbolicDisplay.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {Engine} engine
+ * @param {function(components:[], api:{bind:function(Signal, function, thisArg:*), update: function, bindings:SignalBinding[]})} factory
+ * @param {Class[]} components
+ * @return {ComponentSymbolicDisplay}
+ */
+export function make3DSymbolicDisplay({ engine, factory, components }: Engine): ComponentSymbolicDisplay;
+import { ComponentSymbolicDisplay } from "./ComponentSymbolicDisplay.js";
+//# sourceMappingURL=make3DSymbolicDisplay.d.ts.map

package/editor/process/symbolic/make3DSymbolicDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make3DSymbolicDisplay.d.ts","sourceRoot":"","sources":["make3DSymbolicDisplay.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,gFAFY,wBAAwB,CA+EnC;yCAvFwC,+BAA+B"}

package/editor/process/symbolic/makeCameraSymbolicDisplay.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @returns {ComponentSymbolicDisplay}
+ * @param {Engine} engine
+ */
+export function makeCameraSymbolicDisplay(engine: Engine): ComponentSymbolicDisplay;
+//# sourceMappingURL=makeCameraSymbolicDisplay.d.ts.map