@needle-tools/engine 4.5.5-next.f053174 → 4.5.6

package/lib/engine/extensions/EXT_texture_exr.d.ts

@@ -1,8 +1,8 @@
-import { Texture } from "three";
-import { type GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader.js";
-export declare class EXT_texture_exr implements GLTFLoaderPlugin {
-    get name(): string;
-    private parser;
-    constructor(parser: GLTFParser);
-    loadTexture(textureIndex: any): Promise<Texture> | null;
-}
+import { Texture } from "three";
+import { type GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader.js";
+export declare class EXT_texture_exr implements GLTFLoaderPlugin {
+    get name(): string;
+    private parser;
+    constructor(parser: GLTFParser);
+    loadTexture(textureIndex: any): Promise<Texture> | null;
+}

package/lib/engine/extensions/EXT_texture_exr.js

@@ -1,33 +1,33 @@
-import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader.js";
-import { getParam } from "../engine_utils.js";
-const debug = getParam("debugexr");
-export class EXT_texture_exr {
-    get name() { return "EXT_texture_exr"; }
-    parser;
-    constructor(parser) {
-        this.parser = parser;
-        if (debug)
-            console.log(parser);
-    }
-    loadTexture(textureIndex) {
-        const name = this.name;
-        const parser = this.parser;
-        const json = parser.json;
-        const textureDef = json.textures[textureIndex];
-        if (debug)
-            console.log("EXT_texture_exr.loadTexture", textureIndex, textureDef);
-        if (!textureDef.extensions || !textureDef.extensions[name]) {
-            return null;
-        }
-        const extension = textureDef.extensions[name];
-        // TODO should the loader be cached here?
-        const loader = new EXRLoader(parser.options.manager);
-        if (debug)
-            console.log("EXT_texture_exr.loadTexture", extension);
-        const promise = parser.loadTextureImage(textureIndex, extension.source, loader);
-        return promise;
-    }
-}
-if (typeof window !== "undefined")
-    window.addEventListener('unhandledrejection', (_event) => { });
+import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader.js";
+import { getParam } from "../engine_utils.js";
+const debug = getParam("debugexr");
+export class EXT_texture_exr {
+    get name() { return "EXT_texture_exr"; }
+    parser;
+    constructor(parser) {
+        this.parser = parser;
+        if (debug)
+            console.log(parser);
+    }
+    loadTexture(textureIndex) {
+        const name = this.name;
+        const parser = this.parser;
+        const json = parser.json;
+        const textureDef = json.textures[textureIndex];
+        if (debug)
+            console.log("EXT_texture_exr.loadTexture", textureIndex, textureDef);
+        if (!textureDef.extensions || !textureDef.extensions[name]) {
+            return null;
+        }
+        const extension = textureDef.extensions[name];
+        // TODO should the loader be cached here?
+        const loader = new EXRLoader(parser.options.manager);
+        if (debug)
+            console.log("EXT_texture_exr.loadTexture", extension);
+        const promise = parser.loadTextureImage(textureIndex, extension.source, loader);
+        return promise;
+    }
+}
+if (typeof window !== "undefined")
+    window.addEventListener('unhandledrejection', (_event) => { });
 //# sourceMappingURL=EXT_texture_exr.js.map

package/lib/engine/extensions/NEEDLE_animator_controller_model.d.ts

@@ -1,122 +1,122 @@
-import { AnimationAction, AnimationClip, Object3D } from "three";
-import { InstantiateIdProvider } from "../../engine/engine_networking_instantiate.js";
-import { Animator } from "../../engine-components/Animator.js";
-import { Context } from "../engine_setup.js";
-export declare type AnimatorControllerModel = {
-    name: string;
-    guid: string;
-    parameters: Parameter[];
-    layers: Layer[];
-};
-export declare type Parameter = {
-    name: string;
-    /** the animator string to hash result, test against this if a number is used to get a param value */
-    hash: number;
-    type: AnimatorControllerParameterType;
-    value: number | boolean | string;
-};
-export declare type Layer = {
-    name: string;
-    stateMachine: StateMachine;
-};
-export declare type StateMachine = {
-    defaultState: number;
-    states: State[];
-};
-export declare type State = {
-    name: string;
-    hash: number;
-    motion: Motion;
-    transitions: Transition[];
-    behaviours: StateMachineBehaviourModel[];
-    /** The base speed of the animation */
-    speed?: number;
-    /** Set to a animator controller float parameter name to multiply this ontop of the speed value */
-    speedParameter?: string;
-    /** Cycle offset normalized 0-1, used when starting a animation */
-    cycleOffset?: number;
-    /** If set to a parameter then this is used instead of the CycleOffset value to offset the animation start time */
-    cycleOffsetParameter?: string;
-};
-export declare type StateMachineBehaviourModel = {
-    typeName: string;
-    properties: object;
-    instance?: StateMachineBehaviour;
-};
-export declare abstract class StateMachineBehaviour {
-    _context?: Context;
-    get context(): Context;
-    get isStateMachineBehaviour(): boolean;
-    onStateEnter?(animator: Animator, _animatorStateInfo: AnimatorStateInfo, layerIndex: number): any;
-    onStateUpdate?(animator: Animator, animatorStateInfo: AnimatorStateInfo, _layerIndex: number): any;
-    onStateExit?(animator: Animator, animatorStateInfo: AnimatorStateInfo, layerIndex: number): any;
-}
-export declare class AnimatorStateInfo {
-    /** The name of the animation */
-    readonly name: string;
-    /** The hash of the name */
-    readonly nameHash: number;
-    /** The normalized time of the animation */
-    readonly normalizedTime: number;
-    /** The length of the animation */
-    readonly length: number;
-    /** The current speed of the animation */
-    readonly speed: number;
-    /** The current action playing. It can be used to modify the action */
-    readonly action: AnimationAction | null;
-    /**
-     * If the state has any transitions
-     */
-    readonly hasTransitions: boolean;
-    constructor(state: State, normalizedTime: number, length: number, speed: number);
-}
-export declare type Motion = {
-    name: string;
-    isLooping: boolean;
-    guid?: string;
-    /** clip index in gltf animations array */
-    index?: number;
-    /** the resolved clip */
-    clip?: AnimationClip;
-    /** the clip mapping -> which object has which animationclip */
-    clips?: ClipMapping[];
-    action?: AnimationAction;
-    /** used when a transition points to the same state we need another action to blend */
-    action_loopback?: AnimationAction;
-};
-export declare function createMotion(name: string, id?: InstantiateIdProvider): Motion;
-export declare type ClipMapping = {
-    /** the object this clip is for */
-    node: Object3D;
-    /** the animationclip we resolve from a json ptr */
-    clip: AnimationClip;
-};
-export declare type Transition = {
-    isExit?: boolean;
-    exitTime: number;
-    hasFixedDuration?: boolean;
-    offset: number;
-    duration: number;
-    hasExitTime: number | boolean;
-    destinationState: number | State;
-    conditions: Condition[];
-};
-export declare type Condition = {
-    parameter: string;
-    mode: AnimatorConditionMode;
-    threshold: number;
-};
-export declare enum AnimatorConditionMode {
-    If = 1,
-    IfNot = 2,
-    Greater = 3,
-    Less = 4,
-    Equals = 6,
-    NotEqual = 7
-}
-export declare enum AnimatorControllerParameterType {
-    Float = 1,
-    Int = 3,
-    Bool = 4,
-    Trigger = 9
-}
+import { AnimationAction, AnimationClip, Object3D } from "three";
+import { InstantiateIdProvider } from "../../engine/engine_networking_instantiate.js";
+import { Animator } from "../../engine-components/Animator.js";
+import { Context } from "../engine_setup.js";
+export declare type AnimatorControllerModel = {
+    name: string;
+    guid: string;
+    parameters: Parameter[];
+    layers: Layer[];
+};
+export declare type Parameter = {
+    name: string;
+    /** the animator string to hash result, test against this if a number is used to get a param value */
+    hash: number;
+    type: AnimatorControllerParameterType;
+    value: number | boolean | string;
+};
+export declare type Layer = {
+    name: string;
+    stateMachine: StateMachine;
+};
+export declare type StateMachine = {
+    defaultState: number;
+    states: State[];
+};
+export declare type State = {
+    name: string;
+    hash: number;
+    motion: Motion;
+    transitions: Transition[];
+    behaviours: StateMachineBehaviourModel[];
+    /** The base speed of the animation */
+    speed?: number;
+    /** Set to a animator controller float parameter name to multiply this ontop of the speed value */
+    speedParameter?: string;
+    /** Cycle offset normalized 0-1, used when starting a animation */
+    cycleOffset?: number;
+    /** If set to a parameter then this is used instead of the CycleOffset value to offset the animation start time */
+    cycleOffsetParameter?: string;
+};
+export declare type StateMachineBehaviourModel = {
+    typeName: string;
+    properties: object;
+    instance?: StateMachineBehaviour;
+};
+export declare abstract class StateMachineBehaviour {
+    _context?: Context;
+    get context(): Context;
+    get isStateMachineBehaviour(): boolean;
+    onStateEnter?(animator: Animator, _animatorStateInfo: AnimatorStateInfo, layerIndex: number): any;
+    onStateUpdate?(animator: Animator, animatorStateInfo: AnimatorStateInfo, _layerIndex: number): any;
+    onStateExit?(animator: Animator, animatorStateInfo: AnimatorStateInfo, layerIndex: number): any;
+}
+export declare class AnimatorStateInfo {
+    /** The name of the animation */
+    readonly name: string;
+    /** The hash of the name */
+    readonly nameHash: number;
+    /** The normalized time of the animation */
+    readonly normalizedTime: number;
+    /** The length of the animation */
+    readonly length: number;
+    /** The current speed of the animation */
+    readonly speed: number;
+    /** The current action playing. It can be used to modify the action */
+    readonly action: AnimationAction | null;
+    /**
+     * If the state has any transitions
+     */
+    readonly hasTransitions: boolean;
+    constructor(state: State, normalizedTime: number, length: number, speed: number);
+}
+export declare type Motion = {
+    name: string;
+    isLooping: boolean;
+    guid?: string;
+    /** clip index in gltf animations array */
+    index?: number;
+    /** the resolved clip */
+    clip?: AnimationClip;
+    /** the clip mapping -> which object has which animationclip */
+    clips?: ClipMapping[];
+    action?: AnimationAction;
+    /** used when a transition points to the same state we need another action to blend */
+    action_loopback?: AnimationAction;
+};
+export declare function createMotion(name: string, id?: InstantiateIdProvider): Motion;
+export declare type ClipMapping = {
+    /** the object this clip is for */
+    node: Object3D;
+    /** the animationclip we resolve from a json ptr */
+    clip: AnimationClip;
+};
+export declare type Transition = {
+    isExit?: boolean;
+    exitTime: number;
+    hasFixedDuration?: boolean;
+    offset: number;
+    duration: number;
+    hasExitTime: number | boolean;
+    destinationState: number | State;
+    conditions: Condition[];
+};
+export declare type Condition = {
+    parameter: string;
+    mode: AnimatorConditionMode;
+    threshold: number;
+};
+export declare enum AnimatorConditionMode {
+    If = 1,
+    IfNot = 2,
+    Greater = 3,
+    Less = 4,
+    Equals = 6,
+    NotEqual = 7
+}
+export declare enum AnimatorControllerParameterType {
+    Float = 1,
+    Int = 3,
+    Bool = 4,
+    Trigger = 9
+}

package/lib/engine/extensions/NEEDLE_animator_controller_model.js

@@ -1,96 +1,96 @@
-import { AnimationClip, MathUtils } from "three";
-import { Context } from "../engine_setup.js";
-export class StateMachineBehaviour {
-    _context;
-    get context() { return this._context ?? Context.Current; }
-    get isStateMachineBehaviour() { return true; }
-}
-export class AnimatorStateInfo {
-    /** The name of the animation */
-    name;
-    /** The hash of the name */
-    nameHash;
-    /** The normalized time of the animation */
-    normalizedTime;
-    /** The length of the animation */
-    length;
-    /** The current speed of the animation */
-    speed;
-    /** The current action playing. It can be used to modify the action */
-    action;
-    /**
-     * If the state has any transitions
-     */
-    hasTransitions;
-    constructor(state, normalizedTime, length, speed) {
-        this.name = state.name;
-        this.nameHash = state.hash;
-        this.normalizedTime = normalizedTime;
-        this.length = length;
-        this.speed = speed;
-        this.action = state.motion.action || null;
-        this.hasTransitions = state.transitions?.length > 0 || false;
-    }
-}
-export function createMotion(name, id) {
-    return {
-        name: "Empty",
-        isLooping: false,
-        guid: id?.generateUUID() ?? MathUtils.generateUUID(),
-        index: -1,
-        clip: new AnimationClip(name, 0, []),
-    };
-}
-/// <summary>
-///   <para>The mode of the condition.</para>
-/// </summary>
-export var AnimatorConditionMode;
-(function (AnimatorConditionMode) {
-    /// <summary>
-    ///   <para>The condition is true when the parameter value is true.</para>
-    /// </summary>
-    AnimatorConditionMode[AnimatorConditionMode["If"] = 1] = "If";
-    /// <summary>
-    ///   <para>The condition is true when the parameter value is false.</para>
-    /// </summary>
-    AnimatorConditionMode[AnimatorConditionMode["IfNot"] = 2] = "IfNot";
-    /// <summary>
-    ///   <para>The condition is true when parameter value is greater than the threshold.</para>
-    /// </summary>
-    AnimatorConditionMode[AnimatorConditionMode["Greater"] = 3] = "Greater";
-    /// <summary>
-    ///   <para>The condition is true when the parameter value is less than the threshold.</para>
-    /// </summary>
-    AnimatorConditionMode[AnimatorConditionMode["Less"] = 4] = "Less";
-    /// <summary>
-    ///   <para>The condition is true when parameter value is equal to the threshold.</para>
-    /// </summary>
-    AnimatorConditionMode[AnimatorConditionMode["Equals"] = 6] = "Equals";
-    /// <summary>
-    ///   <para>The condition is true when the parameter value is not equal to the threshold.</para>
-    /// </summary>
-    AnimatorConditionMode[AnimatorConditionMode["NotEqual"] = 7] = "NotEqual";
-})(AnimatorConditionMode || (AnimatorConditionMode = {}));
-/// <summary>
-///   <para>The type of the parameter.</para>
-/// </summary>
-export var AnimatorControllerParameterType;
-(function (AnimatorControllerParameterType) {
-    /// <summary>
-    ///   <para>Float type parameter.</para>
-    /// </summary>
-    AnimatorControllerParameterType[AnimatorControllerParameterType["Float"] = 1] = "Float";
-    /// <summary>
-    ///   <para>Int type parameter.</para>
-    /// </summary>
-    AnimatorControllerParameterType[AnimatorControllerParameterType["Int"] = 3] = "Int";
-    /// <summary>
-    ///   <para>Boolean type parameter.</para>
-    /// </summary>
-    AnimatorControllerParameterType[AnimatorControllerParameterType["Bool"] = 4] = "Bool";
-    /// <summary>
-    ///   <para>Trigger type parameter.</para>
-    /// </summary>
-    AnimatorControllerParameterType[AnimatorControllerParameterType["Trigger"] = 9] = "Trigger";
-})(AnimatorControllerParameterType || (AnimatorControllerParameterType = {}));
+import { AnimationClip, MathUtils } from "three";
+import { Context } from "../engine_setup.js";
+export class StateMachineBehaviour {
+    _context;
+    get context() { return this._context ?? Context.Current; }
+    get isStateMachineBehaviour() { return true; }
+}
+export class AnimatorStateInfo {
+    /** The name of the animation */
+    name;
+    /** The hash of the name */
+    nameHash;
+    /** The normalized time of the animation */
+    normalizedTime;
+    /** The length of the animation */
+    length;
+    /** The current speed of the animation */
+    speed;
+    /** The current action playing. It can be used to modify the action */
+    action;
+    /**
+     * If the state has any transitions
+     */
+    hasTransitions;
+    constructor(state, normalizedTime, length, speed) {
+        this.name = state.name;
+        this.nameHash = state.hash;
+        this.normalizedTime = normalizedTime;
+        this.length = length;
+        this.speed = speed;
+        this.action = state.motion.action || null;
+        this.hasTransitions = state.transitions?.length > 0 || false;
+    }
+}
+export function createMotion(name, id) {
+    return {
+        name: "Empty",
+        isLooping: false,
+        guid: id?.generateUUID() ?? MathUtils.generateUUID(),
+        index: -1,
+        clip: new AnimationClip(name, 0, []),
+    };
+}
+/// <summary>
+///   <para>The mode of the condition.</para>
+/// </summary>
+export var AnimatorConditionMode;
+(function (AnimatorConditionMode) {
+    /// <summary>
+    ///   <para>The condition is true when the parameter value is true.</para>
+    /// </summary>
+    AnimatorConditionMode[AnimatorConditionMode["If"] = 1] = "If";
+    /// <summary>
+    ///   <para>The condition is true when the parameter value is false.</para>
+    /// </summary>
+    AnimatorConditionMode[AnimatorConditionMode["IfNot"] = 2] = "IfNot";
+    /// <summary>
+    ///   <para>The condition is true when parameter value is greater than the threshold.</para>
+    /// </summary>
+    AnimatorConditionMode[AnimatorConditionMode["Greater"] = 3] = "Greater";
+    /// <summary>
+    ///   <para>The condition is true when the parameter value is less than the threshold.</para>
+    /// </summary>
+    AnimatorConditionMode[AnimatorConditionMode["Less"] = 4] = "Less";
+    /// <summary>
+    ///   <para>The condition is true when parameter value is equal to the threshold.</para>
+    /// </summary>
+    AnimatorConditionMode[AnimatorConditionMode["Equals"] = 6] = "Equals";
+    /// <summary>
+    ///   <para>The condition is true when the parameter value is not equal to the threshold.</para>
+    /// </summary>
+    AnimatorConditionMode[AnimatorConditionMode["NotEqual"] = 7] = "NotEqual";
+})(AnimatorConditionMode || (AnimatorConditionMode = {}));
+/// <summary>
+///   <para>The type of the parameter.</para>
+/// </summary>
+export var AnimatorControllerParameterType;
+(function (AnimatorControllerParameterType) {
+    /// <summary>
+    ///   <para>Float type parameter.</para>
+    /// </summary>
+    AnimatorControllerParameterType[AnimatorControllerParameterType["Float"] = 1] = "Float";
+    /// <summary>
+    ///   <para>Int type parameter.</para>
+    /// </summary>
+    AnimatorControllerParameterType[AnimatorControllerParameterType["Int"] = 3] = "Int";
+    /// <summary>
+    ///   <para>Boolean type parameter.</para>
+    /// </summary>
+    AnimatorControllerParameterType[AnimatorControllerParameterType["Bool"] = 4] = "Bool";
+    /// <summary>
+    ///   <para>Trigger type parameter.</para>
+    /// </summary>
+    AnimatorControllerParameterType[AnimatorControllerParameterType["Trigger"] = 9] = "Trigger";
+})(AnimatorControllerParameterType || (AnimatorControllerParameterType = {}));
 //# sourceMappingURL=NEEDLE_animator_controller_model.js.map

package/lib/engine/extensions/NEEDLE_components.d.ts

@@ -1,35 +1,35 @@
-import { Object3D } from "three";
-import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
-import { type GLTF, type GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { type NodeToObjectMap, type ObjectToNodeMap, SerializationContext } from "../engine_serialization_core.js";
-export declare const debug: string | number | boolean;
-export declare const EXTENSION_NAME = "NEEDLE_components";
-declare class ExportData {
-    node: Object3D;
-    nodeIndex: number;
-    nodeDef: any;
-    constructor(node: Object3D, nodeIndex: number, nodeDef: any);
-}
-export declare class NEEDLE_components implements GLTFLoaderPlugin {
-    get name(): string;
-    parser?: GLTFParser;
-    nodeToObjectMap: NodeToObjectMap;
-    /** The loaded gltf */
-    gltf: GLTF | null;
-    exportContext: {
-        [nodeIndex: number]: ExportData;
-    };
-    objectToNodeMap: ObjectToNodeMap;
-    context: SerializationContext;
-    writer?: any;
-    registerExport(exp: GLTFExporter): void;
-    beforeParse(): void;
-    serializeUserData(node: Object3D, _nodeDef: any): boolean;
-    afterSerializeUserData(node: Object3D, _nodeDef: any): void;
-    writeNode(node: Object3D, nodeDef: any): void;
-    afterParse(input: any): void;
-    beforeRoot(): null;
-    afterRoot(result: GLTF): Promise<void>;
-    private createComponents;
-}
-export {};
+import { Object3D } from "three";
+import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
+import { type GLTF, type GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { type NodeToObjectMap, type ObjectToNodeMap, SerializationContext } from "../engine_serialization_core.js";
+export declare const debug: string | number | boolean;
+export declare const EXTENSION_NAME = "NEEDLE_components";
+declare class ExportData {
+    node: Object3D;
+    nodeIndex: number;
+    nodeDef: any;
+    constructor(node: Object3D, nodeIndex: number, nodeDef: any);
+}
+export declare class NEEDLE_components implements GLTFLoaderPlugin {
+    get name(): string;
+    parser?: GLTFParser;
+    nodeToObjectMap: NodeToObjectMap;
+    /** The loaded gltf */
+    gltf: GLTF | null;
+    exportContext: {
+        [nodeIndex: number]: ExportData;
+    };
+    objectToNodeMap: ObjectToNodeMap;
+    context: SerializationContext;
+    writer?: any;
+    registerExport(exp: GLTFExporter): void;
+    beforeParse(): void;
+    serializeUserData(node: Object3D, _nodeDef: any): boolean;
+    afterSerializeUserData(node: Object3D, _nodeDef: any): void;
+    writeNode(node: Object3D, nodeDef: any): void;
+    afterParse(input: any): void;
+    beforeRoot(): null;
+    afterRoot(result: GLTF): Promise<void>;
+    private createComponents;
+}
+export {};