@needle-tools/engine 4.4.0-beta → 4.4.0-beta.2

package/lib/engine/engine_types.js

@@ -1,89 +1,89 @@
-import { Vector3 } from "three";
-import { CircularBuffer } from "./engine_utils.js";
-export var HideFlags;
-(function (HideFlags) {
-    HideFlags[HideFlags["None"] = 0] = "None";
-    /** When enabled the glTF exporter will omit this object and all children from being exported */
-    HideFlags[HideFlags["DontExport"] = 1] = "DontExport";
-})(HideFlags || (HideFlags = {}));
-export function isComponent(obj) {
-    return obj && obj.isComponent;
-}
-export const $physicsKey = Symbol("object");
-const contactsVectorBuffer = new CircularBuffer(() => new Vector3(), 20);
-/**
- * Holds information about physics contacts
- */
-export class ContactPoint {
-    _point;
-    _normal;
-    _tangentVelocity;
-    /** the distance of the collision point */
-    distance;
-    /** the impulse velocity */
-    impulse;
-    friction;
-    /** worldspace point */
-    get point() {
-        const target = contactsVectorBuffer.get();
-        return target.set(this._point.x, this._point.y, this._point.z);
-    }
-    /** worldspace normal */
-    get normal() {
-        const target = contactsVectorBuffer.get();
-        return target.set(this._normal.x, this._normal.y, this._normal.z);
-    }
-    /** worldspace tangent */
-    get tangentVelocity() {
-        const target = contactsVectorBuffer.get();
-        return target.set(this._tangentVelocity.x, this._tangentVelocity.y, this._tangentVelocity.z);
-    }
-    /** @internal */
-    constructor(point, dist, normal, impulse, friction, tangentVelocity) {
-        this._point = point;
-        this.distance = dist;
-        this._normal = normal;
-        this.impulse = impulse;
-        this.friction = friction;
-        this._tangentVelocity = tangentVelocity;
-    }
-}
-/**
- * Holds information about a collision event. Includes a list of contact points and the colliders involved
- */
-export class Collision {
-    /** The contact points of this collision. Contains information about positions, normals, distance, friction, impulse... */
-    contacts;
-    /** @internal */
-    constructor(obj, otherCollider, contacts) {
-        this.me = obj;
-        this._collider = otherCollider;
-        this._gameObject = otherCollider.gameObject;
-        this.contacts = contacts;
-    }
-    /** the gameobject this collision event belongs to (e.g. if onCollisionEnter is called then `me` is the same as `this.gameObject`) */
-    me;
-    _collider;
-    /** the other collider the collision happened with */
-    get collider() {
-        return this._collider;
-    }
-    _gameObject;
-    /** the other object the collision happened with */
-    get gameObject() {
-        return this._gameObject;
-    }
-    /** the other rigidbody we hit, null if none attached */
-    get rigidBody() {
-        return this.collider?.attachedRigidbody;
-    }
-}
-export class SphereOverlapResult {
-    object;
-    collider;
-    constructor(object, collider) {
-        this.object = object;
-        this.collider = collider;
-    }
-}
+import { Vector3 } from "three";
+import { CircularBuffer } from "./engine_utils.js";
+export var HideFlags;
+(function (HideFlags) {
+    HideFlags[HideFlags["None"] = 0] = "None";
+    /** When enabled the glTF exporter will omit this object and all children from being exported */
+    HideFlags[HideFlags["DontExport"] = 1] = "DontExport";
+})(HideFlags || (HideFlags = {}));
+export function isComponent(obj) {
+    return obj && obj.isComponent;
+}
+export const $physicsKey = Symbol("object");
+const contactsVectorBuffer = new CircularBuffer(() => new Vector3(), 20);
+/**
+ * Holds information about physics contacts
+ */
+export class ContactPoint {
+    _point;
+    _normal;
+    _tangentVelocity;
+    /** the distance of the collision point */
+    distance;
+    /** the impulse velocity */
+    impulse;
+    friction;
+    /** worldspace point */
+    get point() {
+        const target = contactsVectorBuffer.get();
+        return target.set(this._point.x, this._point.y, this._point.z);
+    }
+    /** worldspace normal */
+    get normal() {
+        const target = contactsVectorBuffer.get();
+        return target.set(this._normal.x, this._normal.y, this._normal.z);
+    }
+    /** worldspace tangent */
+    get tangentVelocity() {
+        const target = contactsVectorBuffer.get();
+        return target.set(this._tangentVelocity.x, this._tangentVelocity.y, this._tangentVelocity.z);
+    }
+    /** @internal */
+    constructor(point, dist, normal, impulse, friction, tangentVelocity) {
+        this._point = point;
+        this.distance = dist;
+        this._normal = normal;
+        this.impulse = impulse;
+        this.friction = friction;
+        this._tangentVelocity = tangentVelocity;
+    }
+}
+/**
+ * Holds information about a collision event. Includes a list of contact points and the colliders involved
+ */
+export class Collision {
+    /** The contact points of this collision. Contains information about positions, normals, distance, friction, impulse... */
+    contacts;
+    /** @internal */
+    constructor(obj, otherCollider, contacts) {
+        this.me = obj;
+        this._collider = otherCollider;
+        this._gameObject = otherCollider.gameObject;
+        this.contacts = contacts;
+    }
+    /** the gameobject this collision event belongs to (e.g. if onCollisionEnter is called then `me` is the same as `this.gameObject`) */
+    me;
+    _collider;
+    /** the other collider the collision happened with */
+    get collider() {
+        return this._collider;
+    }
+    _gameObject;
+    /** the other object the collision happened with */
+    get gameObject() {
+        return this._gameObject;
+    }
+    /** the other rigidbody we hit, null if none attached */
+    get rigidBody() {
+        return this.collider?.attachedRigidbody;
+    }
+}
+export class SphereOverlapResult {
+    object;
+    collider;
+    constructor(object, collider) {
+        this.object = object;
+        this.collider = collider;
+    }
+}
 //# sourceMappingURL=engine_types.js.map

package/lib/engine/engine_typestore.d.ts

@@ -1,28 +1,28 @@
-declare type Type = new (...args: any[]) => any;
-declare class _TypeStore {
-    private _types;
-    constructor();
-    /**
-     * add a type to the store
-     */
-    add(key: string, type: Type): void;
-    /**
-     * @returns the type for the given key if registered
-     */
-    get(key: string): Type | null;
-    /**
-     * @returns the key/name for the given type if registered
-     */
-    getKey(type: Type): string | null;
-}
-export declare const $BuiltInTypeFlag: unique symbol;
-export declare const TypeStore: _TypeStore;
-/**
- * add to a class declaration to automatically register it to the TypeStore (required for HMR right now)
- *
- * `@registerType`
- *
- * `export class MyType extends Behaviour { ... }`
- */
-export declare const registerType: (constructor: Type) => void;
-export {};
+declare type Type = new (...args: any[]) => any;
+declare class _TypeStore {
+    private _types;
+    constructor();
+    /**
+     * add a type to the store
+     */
+    add(key: string, type: Type): void;
+    /**
+     * @returns the type for the given key if registered
+     */
+    get(key: string): Type | null;
+    /**
+     * @returns the key/name for the given type if registered
+     */
+    getKey(type: Type): string | null;
+}
+export declare const $BuiltInTypeFlag: unique symbol;
+export declare const TypeStore: _TypeStore;
+/**
+ * add to a class declaration to automatically register it to the TypeStore (required for HMR right now)
+ *
+ * `@registerType`
+ *
+ * `export class MyType extends Behaviour { ... }`
+ */
+export declare const registerType: (constructor: Type) => void;
+export {};

package/lib/engine/engine_typestore.js

@@ -1,56 +1,56 @@
-import { getParam } from "./engine_utils.js";
-const debug = getParam("debugtypes");
-class _TypeStore {
-    _types = new Map();
-    constructor() {
-        if (debug)
-            console.warn("TypeStore: Created", this);
-    }
-    /**
-     * add a type to the store
-     */
-    add(key, type) {
-        if (debug)
-            console.warn("ADD TYPE", key);
-        const existing = this._types.get(key);
-        if (!existing)
-            this._types.set(key, type);
-        else {
-            if (debug) {
-                if (existing !== type) {
-                    console.warn("Type name exists multiple times in your project and may lead to runtime errors:", key);
-                }
-            }
-        }
-    }
-    /**
-     * @returns the type for the given key if registered
-     */
-    get(key) {
-        return this._types.get(key) || null;
-    }
-    /**
-     * @returns the key/name for the given type if registered
-     */
-    getKey(type) {
-        for (const [key, value] of this._types) {
-            if (value === type)
-                return key;
-        }
-        return null;
-    }
-}
-export const $BuiltInTypeFlag = Symbol("BuiltInType");
-export const TypeStore = new _TypeStore();
-/**
- * add to a class declaration to automatically register it to the TypeStore (required for HMR right now)
- *
- * `@registerType`
- *
- * `export class MyType extends Behaviour { ... }`
- */
-export const registerType = function (constructor) {
-    if (!TypeStore.get(constructor.name))
-        TypeStore.add(constructor.name, constructor);
-};
+import { getParam } from "./engine_utils.js";
+const debug = getParam("debugtypes");
+class _TypeStore {
+    _types = new Map();
+    constructor() {
+        if (debug)
+            console.warn("TypeStore: Created", this);
+    }
+    /**
+     * add a type to the store
+     */
+    add(key, type) {
+        if (debug)
+            console.warn("ADD TYPE", key);
+        const existing = this._types.get(key);
+        if (!existing)
+            this._types.set(key, type);
+        else {
+            if (debug) {
+                if (existing !== type) {
+                    console.warn("Type name exists multiple times in your project and may lead to runtime errors:", key);
+                }
+            }
+        }
+    }
+    /**
+     * @returns the type for the given key if registered
+     */
+    get(key) {
+        return this._types.get(key) || null;
+    }
+    /**
+     * @returns the key/name for the given type if registered
+     */
+    getKey(type) {
+        for (const [key, value] of this._types) {
+            if (value === type)
+                return key;
+        }
+        return null;
+    }
+}
+export const $BuiltInTypeFlag = Symbol("BuiltInType");
+export const TypeStore = new _TypeStore();
+/**
+ * add to a class declaration to automatically register it to the TypeStore (required for HMR right now)
+ *
+ * `@registerType`
+ *
+ * `export class MyType extends Behaviour { ... }`
+ */
+export const registerType = function (constructor) {
+    if (!TypeStore.get(constructor.name))
+        TypeStore.add(constructor.name, constructor);
+};
 //# sourceMappingURL=engine_typestore.js.map

package/lib/engine/engine_util_decorator.d.ts

@@ -1,13 +1,13 @@
-import { type Constructor, type IComponent } from "./engine_types.js";
-declare type setter = (v: any) => void;
-declare type getter = () => any;
-/** create accessor callbacks for a field */
-export declare const validate: (set?: setter, get?: getter) => (target: IComponent | any, propertyKey: string, descriptor?: undefined) => void;
-/** Experimental attribute
- * Use to hook into another type's methods and run before the other methods run (similar to Harmony prefixes).
- * Return false to prevent the original method from running.
- */
-export declare const prefix: <T>(type: Constructor<T>) => (target: IComponent | any, _propertyKey: string | {
-    name: string;
-}, _PropertyDescriptor: PropertyDescriptor) => void;
-export {};
+import { type Constructor, type IComponent } from "./engine_types.js";
+declare type setter = (v: any) => void;
+declare type getter = () => any;
+/** create accessor callbacks for a field */
+export declare const validate: (set?: setter, get?: getter) => (target: IComponent | any, propertyKey: string, descriptor?: undefined) => void;
+/** Experimental attribute
+ * Use to hook into another type's methods and run before the other methods run (similar to Harmony prefixes).
+ * Return false to prevent the original method from running.
+ */
+export declare const prefix: <T>(type: Constructor<T>) => (target: IComponent | any, _propertyKey: string | {
+    name: string;
+}, _PropertyDescriptor: PropertyDescriptor) => void;
+export {};

package/lib/engine/engine_util_decorator.js

@@ -1,117 +1,117 @@
-import { Quaternion, Vector2, Vector3, Vector4 } from "three";
-import { isDevEnvironment, LogType, showBalloonMessage } from "./debug/index.js";
-import { $isAssigningProperties } from "./engine_serialization_core.js";
-import { watchWrite } from "./engine_utils.js";
-/** create accessor callbacks for a field */
-export const validate = function (set, get) {
-    // "descriptor : undefined" prevents @validate() to be added to property getters or setters
-    return function (target, propertyKey, descriptor) {
-        createPropertyWrapper(target, propertyKey, descriptor, set, get);
-    };
-};
-function createPropertyWrapper(target, _propertyKey, descriptor, set, get) {
-    if (!get && !set && !target.onValidate)
-        return;
-    // this is not undefined when its a property getter or setter already and not just a field
-    // we currently only support validation of fields
-    if (descriptor !== undefined) {
-        console.error("Invalid usage of validate decorator. Only fields can be validated.", target, _propertyKey, descriptor);
-        showBalloonMessage("Invalid usage of validate decorator. Only fields can be validated. Property: " + _propertyKey, LogType.Error);
-        return;
-    }
-    let propertyKey = "";
-    if (typeof _propertyKey === "string")
-        propertyKey = _propertyKey;
-    else
-        propertyKey = _propertyKey.name;
-    if (target.__internalAwake) {
-        // this is the hidden key we save the original property to
-        const $prop = Symbol(propertyKey);
-        // save the original awake method
-        // we need to delay decoration until the object has been created
-        const awake = target.__internalAwake;
-        target.__internalAwake = function () {
-            if (!this.onValidate) {
-                if (isDevEnvironment())
-                    console.warn("Usage of @validate decorate detected but there is no onValidate method in your class: \"" + target.constructor?.name + "\"");
-                return;
-            }
-            // only build wrapper once per type
-            if (this[$prop] === undefined) {
-                // make sure the field is initialized in a hidden property
-                this[$prop] = this[propertyKey];
-                // For complex types we need to watch the write operation (the underlying values)
-                // Since the object itself doesnt change (normally)
-                // This is relevant if we want to use @validate() on e.g. a Vector3 which is animated from an animationclip
-                const _val = this[propertyKey];
-                if (_val instanceof Vector2 ||
-                    _val instanceof Vector3 ||
-                    _val instanceof Vector4 ||
-                    _val instanceof Quaternion) {
-                    const vec = this[propertyKey];
-                    const cb = () => { this.onValidate(propertyKey); };
-                    watchWrite(vec, cb);
-                }
-                Object.defineProperty(this, propertyKey, {
-                    set: function (v) {
-                        if (this[$isAssigningProperties] === true) {
-                            this[$prop] = v;
-                        }
-                        else {
-                            set?.call(this, v);
-                            const oldValue = this[$prop];
-                            this[$prop] = v;
-                            this.onValidate?.call(this, propertyKey, oldValue);
-                        }
-                    },
-                    get: function () {
-                        get?.call(this);
-                        return this[$prop];
-                    },
-                });
-            }
-            // call the original awake method
-            awake.call(this);
-        };
-    }
-}
-/** Experimental attribute
- * Use to hook into another type's methods and run before the other methods run (similar to Harmony prefixes).
- * Return false to prevent the original method from running.
- */
-export const prefix = function (type) {
-    return function (target, _propertyKey, _PropertyDescriptor) {
-        let propertyKey = "";
-        if (typeof _propertyKey === "string")
-            propertyKey = _propertyKey;
-        else
-            propertyKey = _propertyKey.name;
-        const targetType = type.prototype;
-        const originalProp = Object.getOwnPropertyDescriptor(targetType, propertyKey);
-        if (!originalProp?.value) {
-            console.warn("Can not apply prefix: type does not have method named", _propertyKey, type);
-            return;
-        }
-        const originalValue = originalProp.value;
-        const prefix = target[propertyKey];
-        Object.defineProperty(targetType, propertyKey, {
-            value: function (...args) {
-                const res = prefix?.call(this, ...args);
-                // If the prefix method is async we need to check if the user returned false
-                // In which case we don't want to call the original method
-                if (res instanceof Promise) {
-                    res.then((r) => {
-                        if (r === false)
-                            return;
-                        return originalValue.call(this, ...args);
-                    });
-                    return;
-                }
-                if (res === false)
-                    return;
-                return originalValue.call(this, ...args);
-            },
-        });
-    };
-};
+import { Quaternion, Vector2, Vector3, Vector4 } from "three";
+import { isDevEnvironment, LogType, showBalloonMessage } from "./debug/index.js";
+import { $isAssigningProperties } from "./engine_serialization_core.js";
+import { watchWrite } from "./engine_utils.js";
+/** create accessor callbacks for a field */
+export const validate = function (set, get) {
+    // "descriptor : undefined" prevents @validate() to be added to property getters or setters
+    return function (target, propertyKey, descriptor) {
+        createPropertyWrapper(target, propertyKey, descriptor, set, get);
+    };
+};
+function createPropertyWrapper(target, _propertyKey, descriptor, set, get) {
+    if (!get && !set && !target.onValidate)
+        return;
+    // this is not undefined when its a property getter or setter already and not just a field
+    // we currently only support validation of fields
+    if (descriptor !== undefined) {
+        console.error("Invalid usage of validate decorator. Only fields can be validated.", target, _propertyKey, descriptor);
+        showBalloonMessage("Invalid usage of validate decorator. Only fields can be validated. Property: " + _propertyKey, LogType.Error);
+        return;
+    }
+    let propertyKey = "";
+    if (typeof _propertyKey === "string")
+        propertyKey = _propertyKey;
+    else
+        propertyKey = _propertyKey.name;
+    if (target.__internalAwake) {
+        // this is the hidden key we save the original property to
+        const $prop = Symbol(propertyKey);
+        // save the original awake method
+        // we need to delay decoration until the object has been created
+        const awake = target.__internalAwake;
+        target.__internalAwake = function () {
+            if (!this.onValidate) {
+                if (isDevEnvironment())
+                    console.warn("Usage of @validate decorate detected but there is no onValidate method in your class: \"" + target.constructor?.name + "\"");
+                return;
+            }
+            // only build wrapper once per type
+            if (this[$prop] === undefined) {
+                // make sure the field is initialized in a hidden property
+                this[$prop] = this[propertyKey];
+                // For complex types we need to watch the write operation (the underlying values)
+                // Since the object itself doesnt change (normally)
+                // This is relevant if we want to use @validate() on e.g. a Vector3 which is animated from an animationclip
+                const _val = this[propertyKey];
+                if (_val instanceof Vector2 ||
+                    _val instanceof Vector3 ||
+                    _val instanceof Vector4 ||
+                    _val instanceof Quaternion) {
+                    const vec = this[propertyKey];
+                    const cb = () => { this.onValidate(propertyKey); };
+                    watchWrite(vec, cb);
+                }
+                Object.defineProperty(this, propertyKey, {
+                    set: function (v) {
+                        if (this[$isAssigningProperties] === true) {
+                            this[$prop] = v;
+                        }
+                        else {
+                            set?.call(this, v);
+                            const oldValue = this[$prop];
+                            this[$prop] = v;
+                            this.onValidate?.call(this, propertyKey, oldValue);
+                        }
+                    },
+                    get: function () {
+                        get?.call(this);
+                        return this[$prop];
+                    },
+                });
+            }
+            // call the original awake method
+            awake.call(this);
+        };
+    }
+}
+/** Experimental attribute
+ * Use to hook into another type's methods and run before the other methods run (similar to Harmony prefixes).
+ * Return false to prevent the original method from running.
+ */
+export const prefix = function (type) {
+    return function (target, _propertyKey, _PropertyDescriptor) {
+        let propertyKey = "";
+        if (typeof _propertyKey === "string")
+            propertyKey = _propertyKey;
+        else
+            propertyKey = _propertyKey.name;
+        const targetType = type.prototype;
+        const originalProp = Object.getOwnPropertyDescriptor(targetType, propertyKey);
+        if (!originalProp?.value) {
+            console.warn("Can not apply prefix: type does not have method named", _propertyKey, type);
+            return;
+        }
+        const originalValue = originalProp.value;
+        const prefix = target[propertyKey];
+        Object.defineProperty(targetType, propertyKey, {
+            value: function (...args) {
+                const res = prefix?.call(this, ...args);
+                // If the prefix method is async we need to check if the user returned false
+                // In which case we don't want to call the original method
+                if (res instanceof Promise) {
+                    res.then((r) => {
+                        if (r === false)
+                            return;
+                        return originalValue.call(this, ...args);
+                    });
+                    return;
+                }
+                if (res === false)
+                    return;
+                return originalValue.call(this, ...args);
+            },
+        });
+    };
+};
 //# sourceMappingURL=engine_util_decorator.js.map