@needle-tools/engine 4.7.1 → 4.7.2-alpha

package/lib/engine/engine_animation.d.ts

@@ -1,43 +1,43 @@
-import { AnimationAction, AnimationClip, AnimationMixer, Object3D } from "three";
-import type { Context } from "./engine_context.js";
-import { IAnimationComponent, Model } from "./engine_types.js";
-/**
- * Registry for animation related data. Use {@link registerAnimationMixer} to register an animation mixer instance.
- * Can be accessed from {@link Context.animations} and is used internally e.g. when exporting GLTF files.
- * @category Animation
- */
-export declare class AnimationsRegistry {
-    readonly context: Context;
-    readonly mixers: AnimationMixer[];
-    constructor(context: Context);
-    /** @hidden @internal */
-    onDestroy(): void;
-    /**
-     * Register an animation mixer instance.
-     */
-    registerAnimationMixer(mixer: AnimationMixer): void;
-    /**
-     * Unregister an animation mixer instance.
-     */
-    unregisterAnimationMixer(mixer: AnimationMixer | null | undefined): void;
-}
-/**
- * Utility class for working with animations.
- */
-export declare class AnimationUtils {
-    /**
-     * Tries to get the animation actions from an animation mixer.
-     * @param mixer The animation mixer to get the actions from
-     * @returns The actions or null if the mixer is invalid
-     */
-    static tryGetActionsFromMixer(mixer: AnimationMixer): Array<AnimationAction> | null;
-    static tryGetAnimationClipsFromObjectHierarchy(obj: Object3D, target?: Array<AnimationClip>): Array<AnimationClip>;
-    /**
-     * Assigns animations from a GLTF file to the objects in the scene.
-     * This method will look for objects in the scene that have animations and assign them to the correct objects.
-     * @param file The GLTF file to assign the animations from
-     */
-    static assignAnimationsFromFile(file: Pick<Model, "animations" | "scene">, opts?: {
-        createAnimationComponent(obj: Object3D, animation: AnimationClip): IAnimationComponent;
-    }): void;
-}
+import { AnimationAction, AnimationClip, AnimationMixer, Object3D } from "three";
+import type { Context } from "./engine_context.js";
+import { IAnimationComponent, Model } from "./engine_types.js";
+/**
+ * Registry for animation related data. Use {@link registerAnimationMixer} to register an animation mixer instance.
+ * Can be accessed from {@link Context.animations} and is used internally e.g. when exporting GLTF files.
+ * @category Animation
+ */
+export declare class AnimationsRegistry {
+    readonly context: Context;
+    readonly mixers: AnimationMixer[];
+    constructor(context: Context);
+    /** @hidden @internal */
+    onDestroy(): void;
+    /**
+     * Register an animation mixer instance.
+     */
+    registerAnimationMixer(mixer: AnimationMixer): void;
+    /**
+     * Unregister an animation mixer instance.
+     */
+    unregisterAnimationMixer(mixer: AnimationMixer | null | undefined): void;
+}
+/**
+ * Utility class for working with animations.
+ */
+export declare class AnimationUtils {
+    /**
+     * Tries to get the animation actions from an animation mixer.
+     * @param mixer The animation mixer to get the actions from
+     * @returns The actions or null if the mixer is invalid
+     */
+    static tryGetActionsFromMixer(mixer: AnimationMixer): Array<AnimationAction> | null;
+    static tryGetAnimationClipsFromObjectHierarchy(obj: Object3D, target?: Array<AnimationClip>): Array<AnimationClip>;
+    /**
+     * Assigns animations from a GLTF file to the objects in the scene.
+     * This method will look for objects in the scene that have animations and assign them to the correct objects.
+     * @param file The GLTF file to assign the animations from
+     */
+    static assignAnimationsFromFile(file: Pick<Model, "animations" | "scene">, opts?: {
+        createAnimationComponent(obj: Object3D, animation: AnimationClip): IAnimationComponent;
+    }): void;
+}

package/lib/engine/engine_animation.js

@@ -1,134 +1,134 @@
-import { PropertyBinding } from "three";
-/**
- * Registry for animation related data. Use {@link registerAnimationMixer} to register an animation mixer instance.
- * Can be accessed from {@link Context.animations} and is used internally e.g. when exporting GLTF files.
- * @category Animation
- */
-export class AnimationsRegistry {
-    context;
-    mixers = [];
-    constructor(context) {
-        this.context = context;
-    }
-    /** @hidden @internal */
-    onDestroy() {
-        this.mixers.forEach(mixer => mixer.stopAllAction());
-        this.mixers.length = 0;
-    }
-    /**
-     * Register an animation mixer instance.
-     */
-    registerAnimationMixer(mixer) {
-        if (!mixer) {
-            console.warn("AnimationsRegistry.registerAnimationMixer called with null or undefined mixer");
-            return;
-        }
-        if (this.mixers.includes(mixer))
-            return;
-        this.mixers.push(mixer);
-    }
-    /**
-     * Unregister an animation mixer instance.
-     */
-    unregisterAnimationMixer(mixer) {
-        if (!mixer) {
-            console.warn("AnimationsRegistry.unregisterAnimationMixer called with null or undefined mixer");
-            return;
-        }
-        const index = this.mixers.indexOf(mixer);
-        if (index === -1)
-            return;
-        this.mixers.splice(index, 1);
-    }
-}
-/**
- * Utility class for working with animations.
- */
-export class AnimationUtils {
-    /**
-     * Tries to get the animation actions from an animation mixer.
-     * @param mixer The animation mixer to get the actions from
-     * @returns The actions or null if the mixer is invalid
-     */
-    static tryGetActionsFromMixer(mixer) {
-        const actions = mixer["_actions"];
-        if (!actions)
-            return null;
-        return actions;
-    }
-    static tryGetAnimationClipsFromObjectHierarchy(obj, target) {
-        if (!target)
-            target = new Array();
-        if (!obj) {
-            return target;
-        }
-        else if (obj.animations) {
-            target.push(...obj.animations);
-        }
-        if (obj.children) {
-            for (const child of obj.children) {
-                this.tryGetAnimationClipsFromObjectHierarchy(child, target);
-            }
-        }
-        return target;
-    }
-    /**
-     * Assigns animations from a GLTF file to the objects in the scene.
-     * This method will look for objects in the scene that have animations and assign them to the correct objects.
-     * @param file The GLTF file to assign the animations from
-     */
-    static assignAnimationsFromFile(file, opts) {
-        if (!file || !file.animations) {
-            console.debug("No animations found in file");
-            return;
-        }
-        for (let i = 0; i < file.animations.length; i++) {
-            const animation = file.animations[i];
-            if (!animation.tracks || animation.tracks.length <= 0) {
-                console.warn("Animation has no tracks");
-                continue;
-            }
-            for (const t in animation.tracks) {
-                const track = animation.tracks[t];
-                const parsedPath = PropertyBinding.parseTrackName(track.name);
-                let obj = PropertyBinding.findNode(file.scene, parsedPath.nodeName);
-                if (!obj) {
-                    const objectName = track["__objectName"] ?? track.name.substring(0, track.name.indexOf("."));
-                    // let obj = gltf.scene.getObjectByName(objectName);
-                    // this finds unnamed objects that still have tracks targeting them
-                    obj = file.scene.getObjectByProperty('uuid', objectName);
-                    if (!obj) {
-                        // console.warn("could not find " + objectName, animation, gltf.scene);
-                        continue;
-                    }
-                }
-                let animationComponent = findAnimationGameObjectInParent(obj);
-                if (!animationComponent) {
-                    if (!opts?.createAnimationComponent) {
-                        console.warn("No AnimationComponent found in parent hierarchy of object and no 'createAnimationComponent' callback was provided in options.");
-                        continue;
-                    }
-                    animationComponent = opts.createAnimationComponent(file.scene, animation);
-                }
-                if (animationComponent.addClip) {
-                    animationComponent.addClip(animation);
-                }
-            }
-        }
-        function findAnimationGameObjectInParent(obj) {
-            if (!obj)
-                return null;
-            const components = obj.userData?.components;
-            if (components && components.length > 0) {
-                for (let i = 0; i < components.length; i++) {
-                    const component = components[i];
-                    if (component.isAnimationComponent === true) {
-                        return obj;
-                    }
-                }
-            }
-            return findAnimationGameObjectInParent(obj.parent);
-        }
-    }
-}
+import { PropertyBinding } from "three";
+/**
+ * Registry for animation related data. Use {@link registerAnimationMixer} to register an animation mixer instance.
+ * Can be accessed from {@link Context.animations} and is used internally e.g. when exporting GLTF files.
+ * @category Animation
+ */
+export class AnimationsRegistry {
+    context;
+    mixers = [];
+    constructor(context) {
+        this.context = context;
+    }
+    /** @hidden @internal */
+    onDestroy() {
+        this.mixers.forEach(mixer => mixer.stopAllAction());
+        this.mixers.length = 0;
+    }
+    /**
+     * Register an animation mixer instance.
+     */
+    registerAnimationMixer(mixer) {
+        if (!mixer) {
+            console.warn("AnimationsRegistry.registerAnimationMixer called with null or undefined mixer");
+            return;
+        }
+        if (this.mixers.includes(mixer))
+            return;
+        this.mixers.push(mixer);
+    }
+    /**
+     * Unregister an animation mixer instance.
+     */
+    unregisterAnimationMixer(mixer) {
+        if (!mixer) {
+            console.warn("AnimationsRegistry.unregisterAnimationMixer called with null or undefined mixer");
+            return;
+        }
+        const index = this.mixers.indexOf(mixer);
+        if (index === -1)
+            return;
+        this.mixers.splice(index, 1);
+    }
+}
+/**
+ * Utility class for working with animations.
+ */
+export class AnimationUtils {
+    /**
+     * Tries to get the animation actions from an animation mixer.
+     * @param mixer The animation mixer to get the actions from
+     * @returns The actions or null if the mixer is invalid
+     */
+    static tryGetActionsFromMixer(mixer) {
+        const actions = mixer["_actions"];
+        if (!actions)
+            return null;
+        return actions;
+    }
+    static tryGetAnimationClipsFromObjectHierarchy(obj, target) {
+        if (!target)
+            target = new Array();
+        if (!obj) {
+            return target;
+        }
+        else if (obj.animations) {
+            target.push(...obj.animations);
+        }
+        if (obj.children) {
+            for (const child of obj.children) {
+                this.tryGetAnimationClipsFromObjectHierarchy(child, target);
+            }
+        }
+        return target;
+    }
+    /**
+     * Assigns animations from a GLTF file to the objects in the scene.
+     * This method will look for objects in the scene that have animations and assign them to the correct objects.
+     * @param file The GLTF file to assign the animations from
+     */
+    static assignAnimationsFromFile(file, opts) {
+        if (!file || !file.animations) {
+            console.debug("No animations found in file");
+            return;
+        }
+        for (let i = 0; i < file.animations.length; i++) {
+            const animation = file.animations[i];
+            if (!animation.tracks || animation.tracks.length <= 0) {
+                console.warn("Animation has no tracks");
+                continue;
+            }
+            for (const t in animation.tracks) {
+                const track = animation.tracks[t];
+                const parsedPath = PropertyBinding.parseTrackName(track.name);
+                let obj = PropertyBinding.findNode(file.scene, parsedPath.nodeName);
+                if (!obj) {
+                    const objectName = track["__objectName"] ?? track.name.substring(0, track.name.indexOf("."));
+                    // let obj = gltf.scene.getObjectByName(objectName);
+                    // this finds unnamed objects that still have tracks targeting them
+                    obj = file.scene.getObjectByProperty('uuid', objectName);
+                    if (!obj) {
+                        // console.warn("could not find " + objectName, animation, gltf.scene);
+                        continue;
+                    }
+                }
+                let animationComponent = findAnimationGameObjectInParent(obj);
+                if (!animationComponent) {
+                    if (!opts?.createAnimationComponent) {
+                        console.warn("No AnimationComponent found in parent hierarchy of object and no 'createAnimationComponent' callback was provided in options.");
+                        continue;
+                    }
+                    animationComponent = opts.createAnimationComponent(file.scene, animation);
+                }
+                if (animationComponent.addClip) {
+                    animationComponent.addClip(animation);
+                }
+            }
+        }
+        function findAnimationGameObjectInParent(obj) {
+            if (!obj)
+                return null;
+            const components = obj.userData?.components;
+            if (components && components.length > 0) {
+                for (let i = 0; i < components.length; i++) {
+                    const component = components[i];
+                    if (component.isAnimationComponent === true) {
+                        return obj;
+                    }
+                }
+            }
+            return findAnimationGameObjectInParent(obj.parent);
+        }
+    }
+}
 //# sourceMappingURL=engine_animation.js.map

package/lib/engine/engine_application.d.ts

@@ -1,45 +1,45 @@
-import { Context } from "./engine_setup.js";
-export declare enum ApplicationEvents {
-    Visible = "application-visible",
-    Hidden = "application-hidden",
-    MuteChanged = "application-mutechanged"
-}
-/**
- * Invoked when the user interacts with the page (click, touch, keypress, etc) allowing to play media / audio / start XR
- * @internal
- */
-export declare function internalOnUserInputRegistered(): void;
-/**
- * The Application class can be used to mute audio globally, and to check if the application (canvas) is currently visible (it's tab is active and not minimized).
- */
-export declare class Application extends EventTarget {
-    static get userInteractionRegistered(): boolean;
-    /**  @deprecated use Application.registerWaitForInteraction instead */
-    static readonly registerWaitForAllowAudio: typeof Application.registerWaitForInteraction;
-    /**
-     * Register a callback that will be called when the user interacts with the page (click, touch, keypress, etc).
-     * If the user has already interacted with the page, the callback will be called immediately.
-     * This can be used to wait for user interaction before playing audio, for example.
-     */
-    static registerWaitForInteraction(cb: Function): void;
-    /**
-     * Unregister a callback that was previously registered with registerWaitForInteraction.
-     */
-    static unregisterWaitForInteraction(cb: Function): void;
-    private _mute;
-    /** audio muted? */
-    get muted(): boolean;
-    /** set global audio mute */
-    set muted(value: boolean);
-    private readonly context;
-    /** @returns true if the document is focused */
-    get hasFocus(): boolean;
-    /**
-     * @returns true if the application is currently visible (it's tab is active and not minimized)
-     */
-    get isVisible(): boolean;
-    private _isVisible;
-    /** @internal */
-    constructor(context: Context);
-    private onVisiblityChanged;
-}
+import { Context } from "./engine_setup.js";
+export declare enum ApplicationEvents {
+    Visible = "application-visible",
+    Hidden = "application-hidden",
+    MuteChanged = "application-mutechanged"
+}
+/**
+ * Invoked when the user interacts with the page (click, touch, keypress, etc) allowing to play media / audio / start XR
+ * @internal
+ */
+export declare function internalOnUserInputRegistered(): void;
+/**
+ * The Application class can be used to mute audio globally, and to check if the application (canvas) is currently visible (it's tab is active and not minimized).
+ */
+export declare class Application extends EventTarget {
+    static get userInteractionRegistered(): boolean;
+    /**  @deprecated use Application.registerWaitForInteraction instead */
+    static readonly registerWaitForAllowAudio: typeof Application.registerWaitForInteraction;
+    /**
+     * Register a callback that will be called when the user interacts with the page (click, touch, keypress, etc).
+     * If the user has already interacted with the page, the callback will be called immediately.
+     * This can be used to wait for user interaction before playing audio, for example.
+     */
+    static registerWaitForInteraction(cb: Function): void;
+    /**
+     * Unregister a callback that was previously registered with registerWaitForInteraction.
+     */
+    static unregisterWaitForInteraction(cb: Function): void;
+    private _mute;
+    /** audio muted? */
+    get muted(): boolean;
+    /** set global audio mute */
+    set muted(value: boolean);
+    private readonly context;
+    /** @returns true if the document is focused */
+    get hasFocus(): boolean;
+    /**
+     * @returns true if the application is currently visible (it's tab is active and not minimized)
+     */
+    get isVisible(): boolean;
+    private _isVisible;
+    /** @internal */
+    constructor(context: Context);
+    private onVisiblityChanged;
+}

package/lib/engine/engine_application.js

@@ -1,105 +1,105 @@
-import { isDevEnvironment } from "./debug/index.js";
-export var ApplicationEvents;
-(function (ApplicationEvents) {
-    ApplicationEvents["Visible"] = "application-visible";
-    ApplicationEvents["Hidden"] = "application-hidden";
-    ApplicationEvents["MuteChanged"] = "application-mutechanged";
-})(ApplicationEvents || (ApplicationEvents = {}));
-let userInteractionRegistered = false;
-const userInteractionCallbacks = [];
-/**
- * Invoked when the user interacts with the page (click, touch, keypress, etc) allowing to play media / audio / start XR
- * @internal
- */
-export function internalOnUserInputRegistered() {
-    if (userInteractionRegistered)
-        return;
-    if (isDevEnvironment())
-        console.debug("User interaction registered: audio can now be played");
-    userInteractionRegistered = true;
-    const copy = [...userInteractionCallbacks];
-    userInteractionCallbacks.length = 0;
-    copy.forEach(cb => cb());
-}
-document.addEventListener('mousedown', internalOnUserInputRegistered);
-document.addEventListener('pointerup', internalOnUserInputRegistered);
-document.addEventListener('click', internalOnUserInputRegistered);
-document.addEventListener('dragstart', internalOnUserInputRegistered);
-document.addEventListener('touchend', internalOnUserInputRegistered);
-document.addEventListener('keydown', internalOnUserInputRegistered);
-/**
- * The Application class can be used to mute audio globally, and to check if the application (canvas) is currently visible (it's tab is active and not minimized).
- */
-export class Application extends EventTarget {
-    static get userInteractionRegistered() {
-        return userInteractionRegistered;
-    }
-    /**  @deprecated use Application.registerWaitForInteraction instead */
-    static registerWaitForAllowAudio = Application.registerWaitForInteraction;
-    /**
-     * Register a callback that will be called when the user interacts with the page (click, touch, keypress, etc).
-     * If the user has already interacted with the page, the callback will be called immediately.
-     * This can be used to wait for user interaction before playing audio, for example.
-     */
-    static registerWaitForInteraction(cb) {
-        if (cb !== null) {
-            if (userInteractionRegistered) {
-                cb();
-                return;
-            }
-            if (userInteractionCallbacks.indexOf(cb) === -1)
-                userInteractionCallbacks.push(cb);
-        }
-    }
-    /**
-     * Unregister a callback that was previously registered with registerWaitForInteraction.
-     */
-    static unregisterWaitForInteraction(cb) {
-        const index = userInteractionCallbacks.indexOf(cb);
-        if (index !== -1) {
-            userInteractionCallbacks.splice(index, 1);
-        }
-    }
-    _mute = false;
-    /** audio muted? */
-    get muted() { return this._mute; }
-    /** set global audio mute */
-    set muted(value) {
-        if (value === this._mute)
-            return;
-        this._mute = value;
-        this.dispatchEvent(new Event(ApplicationEvents.MuteChanged));
-    }
-    context;
-    /** @returns true if the document is focused */
-    get hasFocus() {
-        return document.hasFocus();
-    }
-    /**
-     * @returns true if the application is currently visible (it's tab is active and not minimized)
-     */
-    get isVisible() {
-        return this._isVisible;
-    }
-    _isVisible = true;
-    /** @internal */
-    constructor(context) {
-        super();
-        this.context = context;
-        window.addEventListener("visibilitychange", this.onVisiblityChanged.bind(this), false);
-    }
-    onVisiblityChanged(evt) {
-        // console.log(evt.target.visibilityState)
-        switch (evt.target.visibilityState) {
-            case "hidden":
-                this._isVisible = false;
-                this.dispatchEvent(new Event(ApplicationEvents.Hidden));
-                break;
-            case "visible":
-                this._isVisible = true;
-                this.dispatchEvent(new Event(ApplicationEvents.Visible));
-                break;
-        }
-    }
-}
+import { isDevEnvironment } from "./debug/index.js";
+export var ApplicationEvents;
+(function (ApplicationEvents) {
+    ApplicationEvents["Visible"] = "application-visible";
+    ApplicationEvents["Hidden"] = "application-hidden";
+    ApplicationEvents["MuteChanged"] = "application-mutechanged";
+})(ApplicationEvents || (ApplicationEvents = {}));
+let userInteractionRegistered = false;
+const userInteractionCallbacks = [];
+/**
+ * Invoked when the user interacts with the page (click, touch, keypress, etc) allowing to play media / audio / start XR
+ * @internal
+ */
+export function internalOnUserInputRegistered() {
+    if (userInteractionRegistered)
+        return;
+    if (isDevEnvironment())
+        console.debug("User interaction registered: audio can now be played");
+    userInteractionRegistered = true;
+    const copy = [...userInteractionCallbacks];
+    userInteractionCallbacks.length = 0;
+    copy.forEach(cb => cb());
+}
+document.addEventListener('mousedown', internalOnUserInputRegistered);
+document.addEventListener('pointerup', internalOnUserInputRegistered);
+document.addEventListener('click', internalOnUserInputRegistered);
+document.addEventListener('dragstart', internalOnUserInputRegistered);
+document.addEventListener('touchend', internalOnUserInputRegistered);
+document.addEventListener('keydown', internalOnUserInputRegistered);
+/**
+ * The Application class can be used to mute audio globally, and to check if the application (canvas) is currently visible (it's tab is active and not minimized).
+ */
+export class Application extends EventTarget {
+    static get userInteractionRegistered() {
+        return userInteractionRegistered;
+    }
+    /**  @deprecated use Application.registerWaitForInteraction instead */
+    static registerWaitForAllowAudio = Application.registerWaitForInteraction;
+    /**
+     * Register a callback that will be called when the user interacts with the page (click, touch, keypress, etc).
+     * If the user has already interacted with the page, the callback will be called immediately.
+     * This can be used to wait for user interaction before playing audio, for example.
+     */
+    static registerWaitForInteraction(cb) {
+        if (cb !== null) {
+            if (userInteractionRegistered) {
+                cb();
+                return;
+            }
+            if (userInteractionCallbacks.indexOf(cb) === -1)
+                userInteractionCallbacks.push(cb);
+        }
+    }
+    /**
+     * Unregister a callback that was previously registered with registerWaitForInteraction.
+     */
+    static unregisterWaitForInteraction(cb) {
+        const index = userInteractionCallbacks.indexOf(cb);
+        if (index !== -1) {
+            userInteractionCallbacks.splice(index, 1);
+        }
+    }
+    _mute = false;
+    /** audio muted? */
+    get muted() { return this._mute; }
+    /** set global audio mute */
+    set muted(value) {
+        if (value === this._mute)
+            return;
+        this._mute = value;
+        this.dispatchEvent(new Event(ApplicationEvents.MuteChanged));
+    }
+    context;
+    /** @returns true if the document is focused */
+    get hasFocus() {
+        return document.hasFocus();
+    }
+    /**
+     * @returns true if the application is currently visible (it's tab is active and not minimized)
+     */
+    get isVisible() {
+        return this._isVisible;
+    }
+    _isVisible = true;
+    /** @internal */
+    constructor(context) {
+        super();
+        this.context = context;
+        window.addEventListener("visibilitychange", this.onVisiblityChanged.bind(this), false);
+    }
+    onVisiblityChanged(evt) {
+        // console.log(evt.target.visibilityState)
+        switch (evt.target.visibilityState) {
+            case "hidden":
+                this._isVisible = false;
+                this.dispatchEvent(new Event(ApplicationEvents.Hidden));
+                break;
+            case "visible":
+                this._isVisible = true;
+                this.dispatchEvent(new Event(ApplicationEvents.Visible));
+                break;
+        }
+    }
+}
 //# sourceMappingURL=engine_application.js.map