@needle-tools/engine 4.7.1 → 4.7.2-alpha

package/lib/engine/engine_context_registry.d.ts

@@ -1,71 +1,71 @@
-import { type IComponent, type IContext, type LoadedModel } from "./engine_types.js";
-/** The various events that can be dispatched by a Needle Engine {@link IContext} instance
- */
-export declare enum ContextEvent {
-    /** called once when the context is registered to the registry, the context is not fully initialized at this point */
-    ContextRegistered = "ContextRegistered",
-    /** called before the first glb is loaded, can be used to initialize physics engine, is awaited */
-    ContextCreationStart = "ContextCreationStart",
-    /** Called when the context content has been created, before the first frame. This callback may be called multiple time during the lifetime of the context, e.g. every time when the context is created and cleared */
-    ContextCreated = "ContextCreated",
-    /** Called after the first frame has been rendered after creation */
-    ContextFirstFrameRendered = "ContextFirstFrameRendered",
-    /** Called before the context gets destroyed */
-    ContextDestroying = "ContextDestroying",
-    /** Called when the context has been destroyed */
-    ContextDestroyed = "ContextDestroyed",
-    /** Called when the context could not find a camera during creation */
-    MissingCamera = "MissingCamera",
-    /** Called before the context is being cleared (all objects in the scene are being destroyed and state is reset) */
-    ContextClearing = "ContextClearing",
-    /** Called after the context has been cleared (all objects in the scene have been destroyed and state has been reset) */
-    ContextCleared = "ContextCleared"
-}
-export type ContextEventArgs = {
-    event: ContextEvent;
-    context: IContext;
-    files?: LoadedModel[];
-};
-export type ContextCallback = (evt: ContextEventArgs) => void | Promise<any> | IComponent;
-/** Use to register to various Needle Engine context events and to get access to all current instances
- * e.g. when being created in the DOM
- * @example
- * ```typescript
- * import { NeedleEngine } from "./engine/engine_context_registry.js";
- * NeedleEngine.addContextCreatedCallback((evt) => {
- *    console.log("Context created", evt.context);
- * });
- * ```
- * */
-export declare class ContextRegistry {
-    /** The currently active (rendering) Needle Engine context */
-    static get Current(): IContext;
-    /** @internal */
-    static set Current(ctx: IContext);
-    /** Returns the array of all registered Needle Engine contexts. Do not modify */
-    static get All(): import("./engine_context.js").Context[];
-    /** All currently registered Needle Engine contexts. Do not modify */
-    static Registered: IContext[];
-    /** @internal Internal use only */
-    static register(ctx: IContext): void;
-    /** @internal Internal use only */
-    static unregister(ctx: IContext): void;
-    private static _callbacks;
-    /**
-     * Register a callback to be called when the given event occurs
-     */
-    static registerCallback(evt: ContextEvent, callback: ContextCallback): void;
-    /** Unregister a callback */
-    static unregisterCallback(evt: ContextEvent, callback: ContextCallback): void;
-    /** @internal */
-    static dispatchCallback(evt: ContextEvent, context: IContext, extras?: object): true | Promise<any[]>;
-    /**
-     * Register a callback to be called when a context is created
-     */
-    static addContextCreatedCallback(callback: ContextCallback): void;
-    /**
-     * Register a callback to be called when a context is registered
-     */
-    static addContextDestroyedCallback(callback: ContextCallback): void;
-}
-export { ContextRegistry as NeedleEngine };
+import { type IComponent, type IContext, type LoadedModel } from "./engine_types.js";
+/** The various events that can be dispatched by a Needle Engine {@link IContext} instance
+ */
+export declare enum ContextEvent {
+    /** called once when the context is registered to the registry, the context is not fully initialized at this point */
+    ContextRegistered = "ContextRegistered",
+    /** called before the first glb is loaded, can be used to initialize physics engine, is awaited */
+    ContextCreationStart = "ContextCreationStart",
+    /** Called when the context content has been created, before the first frame. This callback may be called multiple time during the lifetime of the context, e.g. every time when the context is created and cleared */
+    ContextCreated = "ContextCreated",
+    /** Called after the first frame has been rendered after creation */
+    ContextFirstFrameRendered = "ContextFirstFrameRendered",
+    /** Called before the context gets destroyed */
+    ContextDestroying = "ContextDestroying",
+    /** Called when the context has been destroyed */
+    ContextDestroyed = "ContextDestroyed",
+    /** Called when the context could not find a camera during creation */
+    MissingCamera = "MissingCamera",
+    /** Called before the context is being cleared (all objects in the scene are being destroyed and state is reset) */
+    ContextClearing = "ContextClearing",
+    /** Called after the context has been cleared (all objects in the scene have been destroyed and state has been reset) */
+    ContextCleared = "ContextCleared"
+}
+export type ContextEventArgs = {
+    event: ContextEvent;
+    context: IContext;
+    files?: LoadedModel[];
+};
+export type ContextCallback = (evt: ContextEventArgs) => void | Promise<any> | IComponent;
+/** Use to register to various Needle Engine context events and to get access to all current instances
+ * e.g. when being created in the DOM
+ * @example
+ * ```typescript
+ * import { NeedleEngine } from "./engine/engine_context_registry.js";
+ * NeedleEngine.addContextCreatedCallback((evt) => {
+ *    console.log("Context created", evt.context);
+ * });
+ * ```
+ * */
+export declare class ContextRegistry {
+    /** The currently active (rendering) Needle Engine context */
+    static get Current(): IContext;
+    /** @internal */
+    static set Current(ctx: IContext);
+    /** Returns the array of all registered Needle Engine contexts. Do not modify */
+    static get All(): import("./engine_context.js").Context[];
+    /** All currently registered Needle Engine contexts. Do not modify */
+    static Registered: IContext[];
+    /** @internal Internal use only */
+    static register(ctx: IContext): void;
+    /** @internal Internal use only */
+    static unregister(ctx: IContext): void;
+    private static _callbacks;
+    /**
+     * Register a callback to be called when the given event occurs
+     */
+    static registerCallback(evt: ContextEvent, callback: ContextCallback): void;
+    /** Unregister a callback */
+    static unregisterCallback(evt: ContextEvent, callback: ContextCallback): void;
+    /** @internal */
+    static dispatchCallback(evt: ContextEvent, context: IContext, extras?: object): true | Promise<any[]>;
+    /**
+     * Register a callback to be called when a context is created
+     */
+    static addContextCreatedCallback(callback: ContextCallback): void;
+    /**
+     * Register a callback to be called when a context is registered
+     */
+    static addContextDestroyedCallback(callback: ContextCallback): void;
+}
+export { ContextRegistry as NeedleEngine };

package/lib/engine/engine_context_registry.js

@@ -1,118 +1,118 @@
-const debug = typeof window !== undefined ? window.location.search.includes("debugcontext") : false;
-/** The various events that can be dispatched by a Needle Engine {@link IContext} instance
- */
-export var ContextEvent;
-(function (ContextEvent) {
-    /** called once when the context is registered to the registry, the context is not fully initialized at this point */
-    ContextEvent["ContextRegistered"] = "ContextRegistered";
-    /** called before the first glb is loaded, can be used to initialize physics engine, is awaited */
-    ContextEvent["ContextCreationStart"] = "ContextCreationStart";
-    /** Called when the context content has been created, before the first frame. This callback may be called multiple time during the lifetime of the context, e.g. every time when the context is created and cleared */
-    ContextEvent["ContextCreated"] = "ContextCreated";
-    /** Called after the first frame has been rendered after creation */
-    ContextEvent["ContextFirstFrameRendered"] = "ContextFirstFrameRendered";
-    /** Called before the context gets destroyed */
-    ContextEvent["ContextDestroying"] = "ContextDestroying";
-    /** Called when the context has been destroyed */
-    ContextEvent["ContextDestroyed"] = "ContextDestroyed";
-    /** Called when the context could not find a camera during creation */
-    ContextEvent["MissingCamera"] = "MissingCamera";
-    /** Called before the context is being cleared (all objects in the scene are being destroyed and state is reset) */
-    ContextEvent["ContextClearing"] = "ContextClearing";
-    /** Called after the context has been cleared (all objects in the scene have been destroyed and state has been reset) */
-    ContextEvent["ContextCleared"] = "ContextCleared";
-})(ContextEvent || (ContextEvent = {}));
-/** Use to register to various Needle Engine context events and to get access to all current instances
- * e.g. when being created in the DOM
- * @example
- * ```typescript
- * import { NeedleEngine } from "./engine/engine_context_registry.js";
- * NeedleEngine.addContextCreatedCallback((evt) => {
- *    console.log("Context created", evt.context);
- * });
- * ```
- * */
-export class ContextRegistry {
-    /** The currently active (rendering) Needle Engine context */
-    static get Current() {
-        return globalThis["NeedleEngine.Context.Current"];
-    }
-    /** @internal */
-    static set Current(ctx) {
-        globalThis["NeedleEngine.Context.Current"] = ctx;
-    }
-    /** Returns the array of all registered Needle Engine contexts. Do not modify */
-    static get All() {
-        return this.Registered;
-    }
-    /** All currently registered Needle Engine contexts. Do not modify */
-    static Registered = [];
-    /** @internal Internal use only */
-    static register(ctx) {
-        if (this.Registered.indexOf(ctx) !== -1)
-            return;
-        if (debug)
-            console.warn("Registering context");
-        this.Registered.push(ctx);
-        this.dispatchCallback(ContextEvent.ContextRegistered, ctx);
-    }
-    /** @internal Internal use only */
-    static unregister(ctx) {
-        const index = this.Registered.indexOf(ctx);
-        if (index === -1)
-            return;
-        if (debug)
-            console.warn("Unregistering context");
-        this.Registered.splice(index, 1);
-    }
-    static _callbacks = {};
-    /**
-     * Register a callback to be called when the given event occurs
-     */
-    static registerCallback(evt, callback) {
-        if (!this._callbacks[evt])
-            this._callbacks[evt] = [];
-        this._callbacks[evt].push(callback);
-    }
-    /** Unregister a callback */
-    static unregisterCallback(evt, callback) {
-        if (!this._callbacks[evt])
-            return;
-        const index = this._callbacks[evt].indexOf(callback);
-        if (index === -1)
-            return;
-        this._callbacks[evt].splice(index, 1);
-    }
-    /** @internal */
-    static dispatchCallback(evt, context, extras) {
-        if (!this._callbacks[evt])
-            return true;
-        const cbArgs = { event: evt, context };
-        if (extras) {
-            for (const key in extras) {
-                cbArgs[key] = extras[key];
-            }
-        }
-        const promises = new Array();
-        this._callbacks[evt].forEach(cb => {
-            const res = cb(cbArgs);
-            if (res instanceof Promise)
-                promises.push(res);
-        });
-        return Promise.all(promises);
-    }
-    /**
-     * Register a callback to be called when a context is created
-     */
-    static addContextCreatedCallback(callback) {
-        this.registerCallback(ContextEvent.ContextCreated, callback);
-    }
-    /**
-     * Register a callback to be called when a context is registered
-     */
-    static addContextDestroyedCallback(callback) {
-        this.registerCallback(ContextEvent.ContextDestroyed, callback);
-    }
-}
-export { ContextRegistry as NeedleEngine };
+const debug = typeof window !== undefined ? window.location.search.includes("debugcontext") : false;
+/** The various events that can be dispatched by a Needle Engine {@link IContext} instance
+ */
+export var ContextEvent;
+(function (ContextEvent) {
+    /** called once when the context is registered to the registry, the context is not fully initialized at this point */
+    ContextEvent["ContextRegistered"] = "ContextRegistered";
+    /** called before the first glb is loaded, can be used to initialize physics engine, is awaited */
+    ContextEvent["ContextCreationStart"] = "ContextCreationStart";
+    /** Called when the context content has been created, before the first frame. This callback may be called multiple time during the lifetime of the context, e.g. every time when the context is created and cleared */
+    ContextEvent["ContextCreated"] = "ContextCreated";
+    /** Called after the first frame has been rendered after creation */
+    ContextEvent["ContextFirstFrameRendered"] = "ContextFirstFrameRendered";
+    /** Called before the context gets destroyed */
+    ContextEvent["ContextDestroying"] = "ContextDestroying";
+    /** Called when the context has been destroyed */
+    ContextEvent["ContextDestroyed"] = "ContextDestroyed";
+    /** Called when the context could not find a camera during creation */
+    ContextEvent["MissingCamera"] = "MissingCamera";
+    /** Called before the context is being cleared (all objects in the scene are being destroyed and state is reset) */
+    ContextEvent["ContextClearing"] = "ContextClearing";
+    /** Called after the context has been cleared (all objects in the scene have been destroyed and state has been reset) */
+    ContextEvent["ContextCleared"] = "ContextCleared";
+})(ContextEvent || (ContextEvent = {}));
+/** Use to register to various Needle Engine context events and to get access to all current instances
+ * e.g. when being created in the DOM
+ * @example
+ * ```typescript
+ * import { NeedleEngine } from "./engine/engine_context_registry.js";
+ * NeedleEngine.addContextCreatedCallback((evt) => {
+ *    console.log("Context created", evt.context);
+ * });
+ * ```
+ * */
+export class ContextRegistry {
+    /** The currently active (rendering) Needle Engine context */
+    static get Current() {
+        return globalThis["NeedleEngine.Context.Current"];
+    }
+    /** @internal */
+    static set Current(ctx) {
+        globalThis["NeedleEngine.Context.Current"] = ctx;
+    }
+    /** Returns the array of all registered Needle Engine contexts. Do not modify */
+    static get All() {
+        return this.Registered;
+    }
+    /** All currently registered Needle Engine contexts. Do not modify */
+    static Registered = [];
+    /** @internal Internal use only */
+    static register(ctx) {
+        if (this.Registered.indexOf(ctx) !== -1)
+            return;
+        if (debug)
+            console.warn("Registering context");
+        this.Registered.push(ctx);
+        this.dispatchCallback(ContextEvent.ContextRegistered, ctx);
+    }
+    /** @internal Internal use only */
+    static unregister(ctx) {
+        const index = this.Registered.indexOf(ctx);
+        if (index === -1)
+            return;
+        if (debug)
+            console.warn("Unregistering context");
+        this.Registered.splice(index, 1);
+    }
+    static _callbacks = {};
+    /**
+     * Register a callback to be called when the given event occurs
+     */
+    static registerCallback(evt, callback) {
+        if (!this._callbacks[evt])
+            this._callbacks[evt] = [];
+        this._callbacks[evt].push(callback);
+    }
+    /** Unregister a callback */
+    static unregisterCallback(evt, callback) {
+        if (!this._callbacks[evt])
+            return;
+        const index = this._callbacks[evt].indexOf(callback);
+        if (index === -1)
+            return;
+        this._callbacks[evt].splice(index, 1);
+    }
+    /** @internal */
+    static dispatchCallback(evt, context, extras) {
+        if (!this._callbacks[evt])
+            return true;
+        const cbArgs = { event: evt, context };
+        if (extras) {
+            for (const key in extras) {
+                cbArgs[key] = extras[key];
+            }
+        }
+        const promises = new Array();
+        this._callbacks[evt].forEach(cb => {
+            const res = cb(cbArgs);
+            if (res instanceof Promise)
+                promises.push(res);
+        });
+        return Promise.all(promises);
+    }
+    /**
+     * Register a callback to be called when a context is created
+     */
+    static addContextCreatedCallback(callback) {
+        this.registerCallback(ContextEvent.ContextCreated, callback);
+    }
+    /**
+     * Register a callback to be called when a context is registered
+     */
+    static addContextDestroyedCallback(callback) {
+        this.registerCallback(ContextEvent.ContextDestroyed, callback);
+    }
+}
+export { ContextRegistry as NeedleEngine };
 //# sourceMappingURL=engine_context_registry.js.map

package/lib/engine/engine_coroutine.d.ts

@@ -1,35 +1,35 @@
-import { Context } from "./engine_setup.js";
-/** Wait for a number of seconds to pass.
- * @param seconds
- * @param context
- * @returns Generator function
- * @example
- * ```typescript
- * function *myCoroutineFunction() {
- *   yield* WaitForSeconds(1);
- * }
- * ```
- */
-export declare function WaitForSeconds(seconds: number, context?: Context | null): Generator<undefined, void, unknown>;
-/** Wait for a number of frames to pass.
- * @param frames
- * @returns Generator function
- * @example
- * ```typescript
- * function *myCoroutineFunction() {
- *    yield* WaitForFrames(10);
- * }
- * ```
- */
-export declare function WaitForFrames(frames: number): Generator<undefined, void, unknown>;
-/** Wait for a promise to resolve.
- * @param promise
- * @returns Generator function
- * @example
- * ```typescript
- * function *myCoroutineFunction() {
- *   yield* WaitForPromise(fetch("https://jsonplaceholder.typicode.com/todos/1"));
- * }
- * ```
- */
-export declare function WaitForPromise(promise: Promise<any>): Generator<undefined, void, unknown>;
+import { Context } from "./engine_setup.js";
+/** Wait for a number of seconds to pass.
+ * @param seconds
+ * @param context
+ * @returns Generator function
+ * @example
+ * ```typescript
+ * function *myCoroutineFunction() {
+ *   yield* WaitForSeconds(1);
+ * }
+ * ```
+ */
+export declare function WaitForSeconds(seconds: number, context?: Context | null): Generator<undefined, void, unknown>;
+/** Wait for a number of frames to pass.
+ * @param frames
+ * @returns Generator function
+ * @example
+ * ```typescript
+ * function *myCoroutineFunction() {
+ *    yield* WaitForFrames(10);
+ * }
+ * ```
+ */
+export declare function WaitForFrames(frames: number): Generator<undefined, void, unknown>;
+/** Wait for a promise to resolve.
+ * @param promise
+ * @returns Generator function
+ * @example
+ * ```typescript
+ * function *myCoroutineFunction() {
+ *   yield* WaitForPromise(fetch("https://jsonplaceholder.typicode.com/todos/1"));
+ * }
+ * ```
+ */
+export declare function WaitForPromise(promise: Promise<any>): Generator<undefined, void, unknown>;

package/lib/engine/engine_coroutine.js

@@ -1,53 +1,53 @@
-import { Context } from "./engine_setup.js";
-/** Wait for a number of seconds to pass.
- * @param seconds
- * @param context
- * @returns Generator function
- * @example
- * ```typescript
- * function *myCoroutineFunction() {
- *   yield* WaitForSeconds(1);
- * }
- * ```
- */
-export function* WaitForSeconds(seconds, context = null) {
-    const time = context ? context.time : Context.Current.time;
-    const start = time.time;
-    while (time.time - start < seconds) {
-        yield;
-    }
-}
-/** Wait for a number of frames to pass.
- * @param frames
- * @returns Generator function
- * @example
- * ```typescript
- * function *myCoroutineFunction() {
- *    yield* WaitForFrames(10);
- * }
- * ```
- */
-export function* WaitForFrames(frames) {
-    for (let i = 0; i < frames; i++) {
-        yield;
-    }
-}
-/** Wait for a promise to resolve.
- * @param promise
- * @returns Generator function
- * @example
- * ```typescript
- * function *myCoroutineFunction() {
- *   yield* WaitForPromise(fetch("https://jsonplaceholder.typicode.com/todos/1"));
- * }
- * ```
- */
-export function* WaitForPromise(promise) {
-    let isRunning = true;
-    promise.then(() => isRunning = false);
-    promise.catch(() => isRunning = false);
-    while (isRunning) {
-        yield;
-    }
-}
+import { Context } from "./engine_setup.js";
+/** Wait for a number of seconds to pass.
+ * @param seconds
+ * @param context
+ * @returns Generator function
+ * @example
+ * ```typescript
+ * function *myCoroutineFunction() {
+ *   yield* WaitForSeconds(1);
+ * }
+ * ```
+ */
+export function* WaitForSeconds(seconds, context = null) {
+    const time = context ? context.time : Context.Current.time;
+    const start = time.time;
+    while (time.time - start < seconds) {
+        yield;
+    }
+}
+/** Wait for a number of frames to pass.
+ * @param frames
+ * @returns Generator function
+ * @example
+ * ```typescript
+ * function *myCoroutineFunction() {
+ *    yield* WaitForFrames(10);
+ * }
+ * ```
+ */
+export function* WaitForFrames(frames) {
+    for (let i = 0; i < frames; i++) {
+        yield;
+    }
+}
+/** Wait for a promise to resolve.
+ * @param promise
+ * @returns Generator function
+ * @example
+ * ```typescript
+ * function *myCoroutineFunction() {
+ *   yield* WaitForPromise(fetch("https://jsonplaceholder.typicode.com/todos/1"));
+ * }
+ * ```
+ */
+export function* WaitForPromise(promise) {
+    let isRunning = true;
+    promise.then(() => isRunning = false);
+    promise.catch(() => isRunning = false);
+    while (isRunning) {
+        yield;
+    }
+}
 //# sourceMappingURL=engine_coroutine.js.map