@woosh/meep-engine 2.46.3 → 2.46.4

package/package.json

@@ -4,7 +4,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.46.3",
+  "version": "2.46.4",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "scripts": {
@@ -19,7 +19,6 @@
   "files": [
     "build",
     "samples",
-    "src/**/*.d.ts",
     "package.json",
     "README.md"
   ],

package/src/core/UUID.d.ts

@@ -1,3 +0,0 @@
-export default class UUID {
-    static generate(): string
-}

package/src/core/bvh2/BinaryNode.d.ts

@@ -1,13 +0,0 @@
-import {Node} from "./Node";
-import {LeafNode} from "./LeafNode";
-
-export class BinaryNode<T = any> extends Node<T> {
-    left: Node<T>
-    right: Node<T>
-
-    traversePreOrderUsingStack(visitor: (node: Node<T>) => boolean, thisArg?: any): void
-
-    insert(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, value: T): LeafNode<T>
-
-    traverseRayLeafIntersections(startX: number, startY: number, startZ: number, directionX: number, directionY: number, directionZ: number, visitor: (node: LeafNode<T>) => any, thisArg?: any);
-}

package/src/core/bvh2/LeafNode.d.ts

@@ -1,7 +0,0 @@
-import {Node} from "./Node";
-
-export class LeafNode<T> extends Node<T> {
-    object: T
-
-    constructor(object: T, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number)
-}

package/src/core/bvh2/Node.d.ts

@@ -1,9 +0,0 @@
-import {AABB3} from "./aabb3/AABB3";
-import {BinaryNode} from "./BinaryNode";
-
-export class Node<T> extends AABB3 {
-    public parentNode: BinaryNode<T>
-
-
-    readonly leafNodeCount: number
-}

package/src/core/bvh2/aabb3/AABB3.d.ts

@@ -1,46 +0,0 @@
-import Vector3 from "../../geom/Vector3";
-
-export class AABB3 {
-    x0: number
-    y0: number
-    z0: number
-    x1: number
-    y1: number
-    z1: number
-
-    constructor(x0?: number, y0?: number, z0?: number, x1?: number, y1?: number, z1?: number)
-
-    setBounds(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void
-
-    getCenter(target: Vector3): void
-
-    getCenterX(): number
-
-    getCenterY(): number
-
-    getCenterZ(): number
-
-    getExtents(target: Vector3): void
-
-    getExtentsX(): number
-
-    getExtentsY(): number
-
-    getExtentsZ(): number
-
-    expandToFit(box: AABB3): void
-
-    _expandToFitPoint(x: number, y: number, z: number): boolean
-
-    setNegativelyInfiniteBounds(): void
-
-    setInfiniteBounds(): void
-
-    distanceToBox(other: AABB3): number
-
-    applyMatrix4(matrix: ArrayLike<number>): void
-
-    equals(other: AABB3): boolean
-
-    copy(other: AABB3): void
-}

package/src/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.d.ts

@@ -1,25 +0,0 @@
-export class ExplicitBinaryBoundingVolumeHierarchy {
-    readonly root: number
-
-    allocate_node(): number
-
-    release_node(node: number): void
-
-    insert_leaf(node: number): void
-
-    remove_leaf(node: number): void
-
-    collect_nodes_all(destination: ArrayLike<number>, destination_offset: number): void
-
-    node_set_aabb(node: number, aabb: ArrayLike<number>): void
-
-    node_get_aabb(node: number, aabb: ArrayLike<number>): void
-
-    node_set_user_data(node: number, data: number): void
-
-    node_get_user_data(node: number): number
-
-    release_all(): void
-
-    trim(): void
-}

package/src/core/bvh2/traversal/queryBinaryNode_ClippingPlanes.d.ts

@@ -1,5 +0,0 @@
-import {BinaryNode} from "../BinaryNode";
-import {Plane} from "three";
-import {LeafNode} from "../LeafNode";
-
-export function queryBinaryNode_ClippingPlanes(destination: LeafNode[], destinationOffset: number, root: BinaryNode, planes: Plane[]): number

package/src/core/cache/Cache.d.ts

@@ -1,36 +0,0 @@
-export class Cache<K, V> {
-    constructor({
-                    maxWeight,
-                    keyWeigher,
-                    valueWeigher,
-                    keyHashFunction,
-                    keyEqualityFunction,
-                    capacity
-                }?: {
-        maxWeight?: number,
-        keyWeigher?: (key: K) => number,
-        valueWeigher?: (value: V) => number,
-        keyHashFunction?: (key: K) => number,
-        keyEqualityFunction?: (a: K, b: K) => boolean,
-        capacity?: number
-    })
-
-    readonly weight: number
-    readonly maxWeight: number
-
-    size(): number
-
-    put(k: K, v: V): void
-
-    get(k: K): V | null
-
-    contains(k: K): boolean
-
-    remove(k: K): boolean
-
-    clear(): void
-
-    drop(): void
-
-    getOrCompute(key: K, compute: (key: K) => V, compute_context?: any): V
-}

package/src/core/collection/HashMap.d.ts

@@ -1,38 +0,0 @@
-export class HashMap<K, V> implements Iterable<[V, K]> {
-    constructor({
-                    keyHashFunction,
-                    keyEqualityFunction,
-                    capacity,
-                    loadFactor
-                }: {
-        keyHashFunction?: (k: K) => number,
-        keyEqualityFunction?: (a: K, b: K) => boolean,
-        capacity?: number,
-        loadFactor?: number
-    })
-
-    constructor()
-
-    get size(): number
-
-    set(key: K, value: V): void
-
-    get(key: K): V | undefined
-
-    getOrCompute(key: K, compute: (k: K) => V, thisArg?: any): V
-
-    has(key: K): boolean
-
-    delete(key: K): boolean
-
-    clear(): void
-
-    forEach(callback: (value: V, key: K, map: this) => any, thisArg?: any): void
-
-    [Symbol.iterator](): IterableIterator<[K, V]>
-
-    values(): IterableIterator<V>
-
-    keys(): IterableIterator<K>
-}
-

package/src/core/collection/HashSet.d.ts

@@ -1,33 +0,0 @@
-export class HashSet<T> {
-    constructor({
-                    keyHashFunction,
-                    keyEqualityFunction,
-                    capacity
-                }: {
-        keyHashFunction: (k: T) => number,
-        keyEqualityFunction: (a: T, b: T) => boolean,
-        capacity?: number
-    })
-
-    constructor()
-
-    get size(): number
-
-    add(value: T): this
-
-    has(value: T): boolean
-
-    get(value: T): T | undefined
-
-    delete(value: T): boolean
-
-    clear(): void
-
-    forEach(callback: (value: T, key: T, set: this) => any, thisArg?: any): void
-
-    [Symbol.iterator](): IterableIterator<T>
-
-    values(): IterableIterator<T>
-
-    keys(): IterableIterator<T>
-}

package/src/core/collection/Set.d.ts

@@ -1,26 +0,0 @@
-import Signal from "../events/signal/Signal";
-
-export default class Set<T> {
-    on: {
-        added: Signal<T>,
-        removed: Signal<T>
-    }
-
-    constructor(data?: T[])
-
-    contains(el: T): boolean
-
-    add(el: T): boolean
-
-    remove(el: T): boolean
-
-    isEmpty(): boolean
-
-    clear(): void
-
-    setFromArray(source: T[]): void
-
-    forEach(callback: (el: T) => void, thisArg?: any): void
-
-    asArray(): T[]
-}

package/src/core/collection/array/arrayPickBestElement.d.ts

@@ -1 +0,0 @@
-export function arrayPickBestElement<T>(elements: T[], scoreFunction: (T) => number): T | undefined

package/src/core/collection/array/computeHashArray.d.ts

@@ -1 +0,0 @@
-export function computeHashArray<T>(array: T[], hash: (T) => number): number

package/src/core/collection/array/computeHashIntegerArray.d.ts

@@ -1 +0,0 @@
-export function computeHashIntegerArray(...value: number[]): number

package/src/core/collection/array/isArrayEqualStrict.d.ts

@@ -1 +0,0 @@
-export function isArrayEqualStrict<T>(a: ArrayLike<T>, b: ArrayLike<T>): boolean

package/src/core/collection/array/isArraysEqualWithComparator.d.ts

@@ -1 +0,0 @@
-export function isArraysEqualWithComparator<T>(a:ArrayLike<T>, b:ArrayLike<T>, equals:(a:T,b:T)=>boolean):boolean

package/src/core/collection/list/List.d.ts

@@ -1,32 +0,0 @@
-import Signal from "../../events/signal/Signal";
-
-export default class List<T> {
-    get length(): number
-
-    on: {
-        added: Signal<T>,
-        removed: Signal<T, number>
-    }
-
-    constructor(elements?: T[])
-
-    get(index: number): T
-
-    add(el: T): List<T>
-
-    addAll(el: T[]): void
-
-    remove(index: number): T
-
-    removeOneOf(value: T): boolean
-
-    asArray(): T[]
-
-    forEach(f: (element: T, index: number) => any, thisArg?: any): void
-
-    isEmpty(): boolean
-
-    indexOf(el: T): number
-
-    equals(other: List<T>): boolean
-}

package/src/core/collection/list/ListForwarder.d.ts

@@ -1,18 +0,0 @@
-import List from "./List";
-
-export class ListForwarder<T> {
-
-    public destination: List<T>
-
-    constructor()
-
-    add(source: List<T>): boolean
-
-    remove(source: List<T>): boolean
-
-    link(): void
-
-    unlink(): void
-
-    isLinked(): boolean
-}

package/src/core/collection/queue/Deque.d.ts

@@ -1,20 +0,0 @@
-export class Deque<T> {
-    constructor(initial_size?: number)
-
-    isEmpty(): boolean
-
-    clear(): boolean
-
-    size(): number
-
-    remove(e: T): boolean
-
-    has(e: T): boolean
-
-    peek(): T | undefined
-
-    pop(): T
-
-    add(e: T): void
-
-}

package/src/core/color/Color.d.ts

@@ -1,43 +0,0 @@
-import Signal from "../events/signal/Signal";
-
-export class Color {
-    constructor(r?: number, g?: number, b?: number)
-
-    r: number
-    g: number
-    b: number
-
-    readonly onChanged: Signal<number, number, number, number, number, number>
-
-    parse(text: string): void
-
-    setRGB(r: number, g: number, b: number): void
-
-    setHSL(h: number, s: number, l: number): void
-
-    setHCL(h: number, c: number, l: number): void
-
-    setHSI(h: number, s: number, i: number): void
-
-    setHSV(h: number, s: number, v: number): void
-
-    getHSV(): { h: number, s: number, v: number }
-
-    toUint(): number
-
-    fromUint(v: number): void
-
-    equals(other: Color): boolean
-
-    hash(): number
-
-    copy(other: Color): void
-
-    clone(): Color
-
-    fromJSON(json: any): void
-
-    toJSON(): any
-
-    writeToArray(destination: ArrayLike<number>, destination_offset: number): void
-}

package/src/core/events/signal/Signal.d.ts

@@ -1,52 +0,0 @@
-export default class Signal<A = any, B = any, C = any, D = any, E = any, F = any, G = any, H = any> {
-    add(listener: () => any, thisArg?: any): void
-    add(listener: (a: A) => any, thisArg?: any): void
-    add(listener: (a: A, b: B) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E, f: F) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => any, thisArg?: any): void
-
-    addOne(listener: () => any, thisArg?: any): void
-    addOne(listener: (a: A) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E, f: F) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => any, thisArg?: any): void
-
-    remove(listener: () => any, thisArg?: any): void
-    remove(listener: (a: A) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E, f: F) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => any, thisArg?: any): void
-
-    send0(): void
-
-    send1(a: A): void
-
-    send2(a: A, b: B): void
-
-    send3(a: A, b: B, c: C): void
-
-    send4(a: A, b: B, c: C, d: D): void
-
-    send5(a: A, b: B, c: C, d: D, e: E): void
-
-    send6(a: A, b: B, c: C, d: D, e: E, f: F): void
-
-    /**
-     * @deprecated use strongly typed dispatch methods instead (send0, send1 etc)
-     */
-    dispatch(...params: any[]): void
-
-    removeAll(): void
-}

package/src/core/fsm/simple/SimpleStateMachine.d.ts

@@ -1,27 +0,0 @@
-import {SimpleStateMachineDescription} from "./SimpleStateMachineDescription";
-
-export class SimpleStateMachine {
-    get description(): SimpleStateMachineDescription
-
-    constructor(d: SimpleStateMachineDescription)
-
-    addEventHandlerStateEntry(state: number, handler: (old_state: number, current_state: number) => any, thisArg?: any): void
-
-    removeEventHandlerStateEntry(state: number, handler: (old_state: number, current_state: number) => any, thisArg?: any): void
-
-    addEventHandlerStateExit(state: number, handler: (old_state: number, current_state: number) => any, thisArg?: any): void
-
-    removeEventHandlerStateExit(state: number, handler: (old_state: number, current_state: number) => any, thisArg?: any): void
-
-
-    setState(s: number): void
-
-    getState(): number
-
-    /**
-     * @throws if no path could be found to target state
-     */
-    navigateTo(target: number): void
-
-    advance<T>(input: T, preStateChangeHook?: (target: number, input: T) => any): boolean
-}

package/src/core/fsm/simple/SimpleStateMachineDescription.d.ts

@@ -1,21 +0,0 @@
-export class SimpleStateMachineDescription {
-
-    traverseStates(visitor: (state: number) => any, thisArg?: any): void
-
-    stateExists(s: number): boolean
-
-    edgeExists(a: number, b: number): boolean
-
-    createState(id?: number): number
-
-    createEdge(a: number, b: number): void
-
-    setAction<T>(state: number, logic: (input: T) => number): void
-
-    getOutgoingStates(state: number): number[]
-
-    getIncomingStates(state: number): number[]
-
-    findPath(start: number, goal: number): number[] | null
-
-}

package/src/core/geom/3d/SurfacePoint3.d.ts

@@ -1,16 +0,0 @@
-import Vector3 from "../Vector3";
-import {Matrix4} from "three";
-
-export class SurfacePoint3 {
-    normal: Vector3
-    position: Vector3
-    index: number
-
-    applyMatrix4_three(matrix4: Matrix4): void
-
-    applyMatrix4(m4: ArrayLike<number>): void
-
-    copy(other: SurfacePoint3): void
-
-    clone(): SurfacePoint3
-}

package/src/core/geom/3d/aabb/aabb3_build_corners.d.ts

@@ -1 +0,0 @@
-export function aabb3_build_corners(destination: ArrayLike<number>, destination_offset: number, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void

package/src/core/geom/3d/frustum/read_frustum_planes_to_array.d.ts

@@ -1,3 +0,0 @@
-import {Plane} from "three";
-
-export function read_frustum_planes_to_array(planes: Plane[], array: ArrayLike<number>);

package/src/core/geom/3d/shape/AbstractShape3D.d.ts

@@ -1,3 +0,0 @@
-export class AbstractShape3D {
-
-}

package/src/core/geom/3d/shape/TransformedShape3D.d.ts

@@ -1,10 +0,0 @@
-import {AbstractShape3D} from "./AbstractShape3D";
-
-export class TransformedShape3D extends AbstractShape3D {
-
-    static from_m4(subject: AbstractShape3D, matrix: ArrayLike<number>): TransformedShape3D
-
-    static from_translation_scale(subject: AbstractShape3D, translation: ArrayLike<number>, scale: ArrayLike<number>): TransformedShape3D
-
-    static from_scale(subject: AbstractShape3D, scale: ArrayLike<number>): TransformedShape3D
-}

package/src/core/geom/3d/shape/UnionShape3D.d.ts

@@ -1,5 +0,0 @@
-import {AbstractShape3D} from "./AbstractShape3D";
-
-export class UnionShape3D extends AbstractShape3D {
-    static from(children: AbstractShape3D[]): UnionShape3D
-}

package/src/core/geom/3d/shape/UnitCubeShape3D.d.ts

@@ -1,5 +0,0 @@
-import {AbstractShape3D} from "./AbstractShape3D";
-
-export class UnitCubeShape3D extends AbstractShape3D {
-    static INSTANCE: UnitCubeShape3D
-}

package/src/core/geom/3d/shape/UnitSphereShape3D.d.ts

@@ -1,5 +0,0 @@
-import {AbstractShape3D} from "./AbstractShape3D";
-
-export class UnitSphereShape3D extends AbstractShape3D {
-    static INSTANCE: UnitSphereShape3D
-}

package/src/core/geom/AABB2.d.ts

@@ -1,28 +0,0 @@
-export default class AABB2 {
-    x0: number
-    y0: number
-    x1: number
-    y1: number
-
-    constructor(x0: number, y0: number, x1: number, y1: number)
-
-    constructor()
-
-    set(x0: number, y0: number, x1: number, y1: number): void
-
-    copy(other: AABB2): void
-
-    setBoundsUnordered(x0: number, y0: number, x1: number, y1: number): void
-
-    getHeight(): number
-
-    getWidth(): number
-
-    computeArea(): number
-
-    grow(size: number): void
-
-    shrink(size: number): void
-
-    setNegativelyInfiniteBounds(): void
-}

package/src/core/geom/Quaternion.d.ts

@@ -1,74 +0,0 @@
-import Signal from "../events/signal/Signal";
-import {Matrix4, Quaternion as ThreeQuaternion} from "three";
-
-interface Vector3Like {
-    x: number,
-    y: number,
-    z: number
-}
-
-export default class Quaternion {
-    public x: number
-    public y: number
-    public z: number
-    public w: number
-
-    0: number
-    1: number
-    2: number
-    3: number
-
-    readonly onChanged: Signal<number, number, number, number, number, number, number, number>;
-
-    set(x: number, y: number, z: number, w: number): void
-
-    copy(other: Quaternion): void
-    copy(other: ThreeQuaternion): void
-    copy(other: { x: number, y: number, z: number, w: number }): void
-
-    clone():Quaternion
-
-    equals(other: { x: number, y: number, z: number, w: number }): boolean
-
-    slerp(other: Quaternion, t: number): void
-
-    normalize(): void
-
-    __setThreeEuler(threeEuler: any): void
-
-    __setFromEuler(x: number, y: number, z: number, order?: string): void
-
-    threeSetRotationMatrix(result: Matrix4): void
-
-    setFromRotationMatrix(m: Matrix4): void
-
-    decodeFromUint32(uint: number): void
-
-    _lookRotation(forward_x: number, forward_y: number, forward_z: number, up_x: number, up_y: number, up_z: number): void
-
-    lookRotation(v3: Vector3Like, up?: Vector3Like): void
-
-    rotateTowards(other: Quaternion, max_angle: number): void
-
-    toEulerAnglesXYZ(v3: { set(x: number, y: number, z: number): any }): void
-
-    fromEulerAnglesXYZ(x: number, y: number, z: number): void
-
-    fromAxisAngle(axis: Vector3Like, angle: number): void
-
-    computeTwistAngle(axis: Vector3Like): number
-
-    multiplyQuaternions(a: Quaternion, b: Quaternion): void
-
-    angleTo(other: Quaternion): number
-
-    toJSON(): any
-
-    fromJSON(j: any): void
-
-    readFromArray(array: ArrayLike<number>, offset?: number): void
-
-    writeToArray(array: ArrayLike<number>, offset?: number): void
-
-    asArray(): number[]
-}