@needle-tools/engine 3.2.3-alpha → 3.2.4-alpha.1

package/src/engine-components/Animation.ts

@@ -1,9 +1,7 @@
 import { Behaviour } from "./Component";
-import * as THREE from 'three'
-import { AnimationAction, AnimationClip, Vector2 } from "three";
+import { AnimationAction, AnimationClip, AnimationMixer, LoopOnce, LoopRepeat } from "three";
 import { MixerEvent } from "./Animator";
 import { serializable } from "../engine/engine_serialization_decorator";
-import { InstancingUtil } from "../engine/engine_instancing";
 import { Mathf } from "../engine/engine_math";
 import { Vec2 } from "../engine/engine_types";
 import { getParam } from "../engine/engine_utils";
@@ -63,7 +61,7 @@ export class Animation extends Behaviour {
         this.animations = animations;
     }
 
-    set animations(animations: THREE.AnimationClip[]) {
+    set animations(animations: AnimationClip[]) {
         if (debug) console.log("assign animations", animations);
         this.gameObject.animations = animations;
     }
@@ -74,29 +72,29 @@ export class Animation extends Behaviour {
     /**
      * @deprecated Currently unsupported
      */
-    get currentAction(): THREE.AnimationAction | null {
+    get currentAction(): AnimationAction | null {
         return this._currentActions[0];
     }
 
     /**
      * @deprecated Currently unsupported
      */
-    get currentActions(): THREE.AnimationAction[] {
+    get currentActions(): AnimationAction[] {
         return this._currentActions;
     }
 
-    private mixer: THREE.AnimationMixer | undefined = undefined;
-    get actions(): Array<THREE.AnimationAction> {
+    private mixer: AnimationMixer | undefined = undefined;
+    get actions(): Array<AnimationAction> {
         return this._actions;
     }
-    set actions(val: Array<THREE.AnimationAction>) {
+    set actions(val: Array<AnimationAction>) {
         this._actions = val;
     }
-    private _actions: Array<THREE.AnimationAction> = [];
+    private _actions: Array<AnimationAction> = [];
 
-    // private _currentAction: THREE.AnimationAction | null = null;
+    // private _currentAction: AnimationAction | null = null;
 
-    private _currentActions: THREE.AnimationAction[] = [];
+    private _currentActions: AnimationAction[] = [];
     private _handles: AnimationHandle[] = [];
 
     awake() {
@@ -133,7 +131,7 @@ export class Animation extends Behaviour {
         //     InstancingUtil.markDirty(this.gameObject);
     }
 
-    getAction(name: string): THREE.AnimationAction | undefined | null {
+    getAction(name: string): AnimationAction | undefined | null {
         return this.actions?.find(a => a.getClip().name === name);
     }
 
@@ -210,8 +208,8 @@ export class Animation extends Behaviour {
         if (options?.startTime !== undefined) action.time = options.startTime;
 
         if (options?.loop !== undefined)
-            action.loop = options.loop ? THREE.LoopRepeat : THREE.LoopOnce;
-        else action.loop = THREE.LoopOnce;
+            action.loop = options.loop ? LoopRepeat : LoopOnce;
+        else action.loop = LoopOnce;
         action.play();
         if (debug)
             console.log("PLAY", action.getClip().name, action)
@@ -239,14 +237,14 @@ export class Animation extends Behaviour {
         this._didInit = true;
         if (!this.gameObject) return;
         this.actions = [];
-        this.mixer = new THREE.AnimationMixer(this.gameObject);
+        this.mixer = new AnimationMixer(this.gameObject);
     }
 }
 
 
 class AnimationHandle {
-    mixer: THREE.AnimationMixer;
-    action: THREE.AnimationAction;
+    mixer: AnimationMixer;
+    action: AnimationAction;
     promise: Promise<AnimationAction> | null = null;
     resolve: Function | null = null;
     reject: Function | null = null;
@@ -258,7 +256,7 @@ class AnimationHandle {
     private _finishedCallback?: any;
     private _resolvedOrRejectedCallback?: (AnimationHandle) => void;
 
-    constructor(action: THREE.AnimationAction, mixer: THREE.AnimationMixer, opts?: PlayOptions, cb?: (handle: AnimationHandle) => void) {
+    constructor(action: AnimationAction, mixer: AnimationMixer, opts?: PlayOptions, cb?: (handle: AnimationHandle) => void) {
         this.action = action;
         this.mixer = mixer;
         this._resolvedOrRejectedCallback = cb;

package/src/engine-components/Animator.ts

@@ -1,7 +1,6 @@
 import { Behaviour } from "./Component";
-import * as THREE from 'three'
-import { LoopOnce, AnimationActionLoopStyles, AnimationAction } from "three";
-import { getParam, deepClone } from "../engine/engine_utils";
+import { AnimationActionLoopStyles, AnimationAction, AnimationMixer } from "three";
+import { getParam } from "../engine/engine_utils";
 import { AnimatorControllerModel } from "../engine/extensions/NEEDLE_animator_controller_model";
 import { AnimatorController } from "./AnimatorController";
 import { serializable } from "../engine/engine_serialization_decorator";
@@ -12,9 +11,9 @@ const debug = getParam("debuganimator");
 
 export declare class MixerEvent {
     type: string;
-    action: THREE.AnimationAction;
+    action: AnimationAction;
     loopDelta: number;
-    target: THREE.AnimationMixer;
+    target: AnimationMixer;
 }
 
 export declare class PlayOptions {

package/src/engine-components/AnimatorController.ts

@@ -1,9 +1,8 @@
 import { Animator } from "./Animator";
 import { AnimatorConditionMode, AnimatorControllerModel, AnimatorControllerParameterType, AnimatorStateInfo, Condition, createMotion, State, StateMachineBehaviour } from "../engine/extensions/NEEDLE_animator_controller_model";
-import { AnimationAction, AnimationClip, AnimationMixer, AxesHelper, Euler, KeyframeTrack, LoopOnce, LoopRepeat, Matrix4, Object3D, Quaternion, Vector3 } from "three";
+import { AnimationAction, AnimationClip, AnimationMixer, AxesHelper, Euler, KeyframeTrack, LoopOnce, Object3D, Quaternion, Vector3 } from "three";
 import { deepClone, getParam } from "../engine/engine_utils";
 import { Context } from "../engine/engine_setup";
-import * as THREE from "three";
 import { TypeStore } from "../engine/engine_typestore";
 import { assign } from "../engine/engine_serialization_core";
 import { Mathf } from "../engine/engine_math";
@@ -110,7 +109,7 @@ export class AnimatorController {
     get context(): Context | undefined | null { return this.animator?.context; }
 
 
-    // applyRootMotion(obj: THREE.Object3D) {
+    // applyRootMotion(obj: Object3D) {
     //     // this.internalApplyRootMotion(obj);
     // }
 
@@ -160,7 +159,7 @@ export class AnimatorController {
     }
 
 
-    private _mixer!: THREE.AnimationMixer;
+    private _mixer!: AnimationMixer;
     private _activeState?: State;
 
     constructor(model: AnimatorControllerModel) {
@@ -541,10 +540,10 @@ export class AnimatorController {
     private rootMotionHandler?: RootMotionHandler;
 
 
-    // private findRootBone(obj: THREE.Object3D): THREE.Object3D | null {
+    // private findRootBone(obj: Object3D): Object3D | null {
     //     if (this.animationRoot) return this.animationRoot;
     //     if (obj.type === "Bone") {
-    //         this.animationRoot = obj as THREE.Bone;
+    //         this.animationRoot = obj as Bone;
     //         return this.animationRoot;
     //     }
     //     if (obj.children) {
@@ -601,16 +600,16 @@ class TrackEvaluationWrapper {
 
 class RootMotionAction {
 
-    private static lastObjPosition: { [key: string]: THREE.Vector3 } = {};
-    static lastObjRotation: { [key: string]: THREE.Quaternion } = {};
+    private static lastObjPosition: { [key: string]: Vector3 } = {};
+    static lastObjRotation: { [key: string]: Quaternion } = {};
 
     // we remove the first keyframe rotation from the space rotation when updating
-    private static firstKeyframeRotation: { [key: string]: THREE.Quaternion } = {};
+    private static firstKeyframeRotation: { [key: string]: Quaternion } = {};
     // this is used to rotate the space on clip end / start (so the transform direction is correct)
-    private static spaceRotation: { [key: string]: THREE.Quaternion } = {};
-    private static effectiveSpaceRotation: { [key: string]: THREE.Quaternion } = {};
+    private static spaceRotation: { [key: string]: Quaternion } = {};
+    private static effectiveSpaceRotation: { [key: string]: Quaternion } = {};
 
-    private static clipOffsetRotation: { [key: string]: THREE.Quaternion } = {};
+    private static clipOffsetRotation: { [key: string]: Quaternion } = {};
 
 
     set action(val: AnimationAction) {
@@ -631,14 +630,14 @@ class RootMotionAction {
     positionChange: Vector3 = new Vector3();
     rotationChange: Quaternion = new Quaternion();
 
-    constructor(context: Context, root: THREE.Object3D, clip: AnimationClip, positionTrack: KeyframeTrack | null, rotationTrack: KeyframeTrack | null) {
+    constructor(context: Context, root: Object3D, clip: AnimationClip, positionTrack: KeyframeTrack | null, rotationTrack: KeyframeTrack | null) {
         // console.log(this, positionTrack, rotationTrack);
         this.context = context;
         this.root = root;
         this.clip = clip;
 
         if (!RootMotionAction.firstKeyframeRotation[clip.uuid])
-            RootMotionAction.firstKeyframeRotation[clip.uuid] = new THREE.Quaternion();
+            RootMotionAction.firstKeyframeRotation[clip.uuid] = new Quaternion();
         if (rotationTrack) {
             const values = rotationTrack.values;
             RootMotionAction.firstKeyframeRotation[clip.uuid]
@@ -672,7 +671,7 @@ class RootMotionAction {
 
         if (debugRootMotion) 
         {
-            const euler = new THREE.Euler().setFromQuaternion(lastRotation);
+            const euler = new Euler().setFromQuaternion(lastRotation);
             console.log("START", this.clip.name, Mathf.toDegrees(euler.y));
         }
     }
@@ -799,13 +798,13 @@ class RootMotionHandler {
 
     private controller: AnimatorController;
     private handler: RootMotionAction[] = [];
-    private root!: THREE.Object3D;
+    private root!: Object3D;
 
     constructor(controller: AnimatorController) {
         this.controller = controller;
     }
 
-    createClip(mixer: AnimationMixer, root: THREE.Object3D, clip: AnimationClip): AnimationAction {
+    createClip(mixer: AnimationMixer, root: Object3D, clip: AnimationClip): AnimationAction {
         this.root = root;
         let rootName = "";
         if (root && "name" in root) {

package/src/engine-components/AudioListener.ts

@@ -1,18 +1,18 @@
 import { Behaviour, GameObject } from "./Component";
-import * as THREE from "three";
+import { AudioListener as ThreeAudioListener } from "three";
 import { AudioSource } from "./AudioSource";
 import { Camera } from "./Camera";
 
 
 export class AudioListener extends Behaviour {
 
-    get listener(): THREE.AudioListener {
+    get listener(): ThreeAudioListener {
         if (this._listener == null)
-            this._listener = new THREE.AudioListener();
+            this._listener = new ThreeAudioListener();
         return this._listener;
     }
 
-    private _listener: THREE.AudioListener | null = null;
+    private _listener: ThreeAudioListener | null = null;
 
     awake() {
         AudioSource.registerWaitForAllowAudio(() => {

package/src/engine-components/AudioSource.ts

@@ -1,10 +1,10 @@
 import { Behaviour, GameObject } from "./Component";
-import * as THREE from "three";
 import { PositionalAudioHelper } from 'three/examples/jsm/helpers/PositionalAudioHelper.js';
 import { AudioListener } from "./AudioListener";
 import * as utils from "../engine/engine_utils";
 import { serializable } from "../engine/engine_serialization_decorator";
-import { Application, ApplicationEvents } from "../engine/engine_application";
+import { ApplicationEvents } from "../engine/engine_application";
+import { AudioLoader, PositionalAudio } from "three";
 
 
 const debug = utils.getParam("debugaudio");
@@ -146,20 +146,20 @@ export class AudioSource extends Behaviour {
     playInBackground: boolean = true;
 
     private _loop: boolean = false;
-    private sound: THREE.PositionalAudio | null = null;
+    private sound: PositionalAudio | null = null;
     private helper: PositionalAudioHelper | null = null;
     private wasPlaying = false;
-    private audioLoader: THREE.AudioLoader | null = null;
+    private audioLoader: AudioLoader | null = null;
     private shouldPlay: boolean = false;
     // set this from audio context time, used to set clip offset when setting "time" property
     // there is maybe a better way to set a audio clip current time?!
     private _lastClipStartedLoading: string | null = null;
 
-    public get Sound(): THREE.PositionalAudio | null {
+    public get Sound(): PositionalAudio | null {
         if (!this.sound && AudioSource._userInteractionRegistered) {
             const listener = GameObject.getComponent(this.context.mainCamera, AudioListener) ?? GameObject.findObjectOfType(AudioListener, this.context);
             if (listener?.listener) {
-                this.sound = new THREE.PositionalAudio(listener.listener);
+                this.sound = new PositionalAudio(listener.listener);
                 this.gameObject.add(this.sound);
             }
         }
@@ -170,7 +170,7 @@ export class AudioSource extends Behaviour {
 
 
     awake() {
-        this.audioLoader = new THREE.AudioLoader();
+        this.audioLoader = new AudioLoader();
         if (this.playOnAwake) this.shouldPlay = true;
     }
 
@@ -294,7 +294,7 @@ export class AudioSource extends Behaviour {
                 console.log(this.clip);
             if (this.clip.endsWith(".mp3") || this.clip.endsWith(".wav")) {
                 if (!this.audioLoader)
-                    this.audioLoader = new THREE.AudioLoader();
+                    this.audioLoader = new AudioLoader();
                 this.shouldPlay = true;
                 if (this._lastClipStartedLoading === this.clip) {
                     if (debug) console.log("Is currently loading:", this._lastClipStartedLoading, this)

package/src/engine-components/AvatarLoader.ts

@@ -1,28 +1,27 @@
-import { GLTF, GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
-import * as THREE from "three";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
 import * as utils from "../engine/engine_utils"
-// import * as object from "../engine/engine_gltf_builtin_components";
 import * as loaders from "../engine/engine_loaders"
 import { Context } from "../engine/engine_setup";
 import { GameObject } from "./Component";
 import { download_file } from "../engine/engine_web_api";
 import { getLoader } from "../engine/engine_gltf";
 import { InstantiateOptions } from "../engine/engine_gameobject";
+import { Box3, Object3D, Vector3 } from "three";
 
 const debug = utils.getParam("debugavatar");
 
 export class AvatarModel {
-    root: THREE.Object3D;
-    head: THREE.Object3D;
-    leftHand: THREE.Object3D | null;
-    rigthHand: THREE.Object3D | null;
+    root: Object3D;
+    head: Object3D;
+    leftHand: Object3D | null;
+    rigthHand: Object3D | null;
 
 
     get isValid(): boolean {
         return this.head !== null && this.head !== undefined;
     }
 
-    constructor(root: THREE.Object3D, head: THREE.Object3D, leftHand: THREE.Object3D | null, rigthHand: THREE.Object3D | null) {
+    constructor(root: Object3D, head: Object3D, leftHand: Object3D | null, rigthHand: Object3D | null) {
         this.root = root;
         this.head = head;
         this.leftHand = leftHand;
@@ -40,14 +39,14 @@ export class AvatarLoader {
     // private loader: GLTFLoader | null;
     // private avatarModelCache: Map<string, AvatarModel | null> = new Map<string, AvatarModel | null>();
 
-    public async getOrCreateNewAvatarInstance(context: Context, avatarId: string | THREE.Object3D): Promise<AvatarModel | null> {
+    public async getOrCreateNewAvatarInstance(context: Context, avatarId: string | Object3D): Promise<AvatarModel | null> {
 
         if (!avatarId) {
             console.error("Can not create avatar: failed to provide id or root object");
             return null;
         }
 
-        let root: THREE.Object3D | null = null;
+        let root: Object3D | null = null;
         if (typeof avatarId === "string") {
             root = await this.loadAvatar(context, avatarId);
             if (!root) {
@@ -77,7 +76,7 @@ export class AvatarLoader {
     }
 
 
-    private async loadAvatar(context: Context, avatarId: string): Promise<THREE.Object3D | null> {
+    private async loadAvatar(context: Context, avatarId: string): Promise<Object3D | null> {
 
         console.assert(avatarId !== undefined && avatarId !== null && typeof avatarId === "string", "Avatar id must not be null");
         if (avatarId.length <= 0) return null;
@@ -146,9 +145,9 @@ export class AvatarLoader {
     }
 
     // TODO this should be burned to the ground once 🤞 we have proper extras that define object relations.
-    private findAvatar(obj: THREE.Object3D): AvatarModel {
+    private findAvatar(obj: Object3D): AvatarModel {
 
-        const root: THREE.Object3D = obj;
+        const root: Object3D = obj;
         let searchIn = root;
         // some GLTFs have a "scene" root it seems, others don't, we skip the root here if there's only one child
         if (searchIn.children.length == 1)
@@ -163,8 +162,8 @@ export class AvatarLoader {
             head = root;
 
             // normalize size, if the object isn't properly setup the scale might be totally off
-            const boundsSize = new THREE.Vector3();
-            new THREE.Box3().setFromObject(head).getSize(boundsSize);
+            const boundsSize = new Vector3();
+            new Box3().setFromObject(head).getSize(boundsSize);
             const maxAxis = Math.max(boundsSize.x, boundsSize.y, boundsSize.z);
             console.warn("[Custom Avatar] " + "Normalizing head scale, it's too big: " + maxAxis + " meters! Should be < 0.3m");
             if (maxAxis > 0.3) {
@@ -177,7 +176,7 @@ export class AvatarLoader {
     }
 
 
-    private findAvatarPart(obj: THREE.Object3D, searchString: string[]): THREE.Object3D | null {
+    private findAvatarPart(obj: Object3D, searchString: string[]): Object3D | null {
 
         const name = obj.name.toLowerCase();
         let matchesAll = true;

package/src/engine-components/AxesHelper.ts

@@ -11,7 +11,7 @@ export class AxesHelper extends Behaviour {
     @serializable()
     public isGizmo:boolean = true;
 
-    private _axes: THREE.AxesHelper | null = null;
+    private _axes: _AxesHelper | null = null;
 
     onEnable(): void {
         if (this.isGizmo && !params.showGizmos) return;

package/src/engine-components/BasicIKConstraint.ts

@@ -1,6 +1,6 @@
 import { Behaviour, GameObject } from "./Component";
 import * as utils from "./../engine/engine_three_utils";
-import * as THREE from "three"
+import { Vector3 } from "three";
 
 export class BasicIKConstraint extends Behaviour {
 
@@ -33,7 +33,7 @@ export class BasicIKConstraint extends Behaviour {
         let hintDir = utils.getWorldPosition(this.hint).clone();
         hintDir.sub(center);
         
-        let offsetDir = new THREE.Vector3();
+        let offsetDir = new Vector3();
         offsetDir.crossVectors(hintDir, dir0);
         offsetDir.crossVectors(dir0, offsetDir);
         offsetDir.normalize();

package/src/engine-components/BoxHelperComponent.ts

@@ -1,28 +1,28 @@
 import { Behaviour } from "./Component";
-import * as THREE from "three";
 import { getParam } from "../engine/engine_utils";
 import { CreateWireCube, Gizmos } from "../engine/engine_gizmos";
 import { getWorldPosition, getWorldScale } from "../engine/engine_three_utils";
+import { Box3, Color, ColorRepresentation, LineSegments, Object3D, Vector3 } from "three";
 
 const gizmos = getParam("gizmos");
 const debug = getParam("debugboxhelper");
 
 export class BoxHelperComponent extends Behaviour {
 
-    private box: THREE.Box3 | null = null;
-    private static testBox: THREE.Box3 = new THREE.Box3();
+    private box: Box3 | null = null;
+    private static testBox: Box3 = new Box3();
     private _lastMatrixUpdateFrame: number = -1;
-    private static _position: THREE.Vector3 = new THREE.Vector3();
-    private static _size: THREE.Vector3 = new THREE.Vector3(.01, .01, .01);
+    private static _position: Vector3 = new Vector3();
+    private static _size: Vector3 = new Vector3(.01, .01, .01);
 
-    public isInBox(obj: THREE.Object3D, scaleFactor?: number): boolean | undefined {
+    public isInBox(obj: Object3D, scaleFactor?: number): boolean | undefined {
         if (!obj) return undefined;
 
         // if (!obj.geometry.boundingBox) obj.geometry.computeBoundingBox();
         // if (!obj.geometry.boundingBox) return undefined;
 
         if (!this.box) {
-            this.box = new THREE.Box3();
+            this.box = new Box3();
         }
 
 
@@ -56,14 +56,14 @@ export class BoxHelperComponent extends Behaviour {
         return intersects;
     }
 
-    public intersects(box: THREE.Box3): boolean {
+    public intersects(box: Box3): boolean {
         if (!box) return false;
         return this.updateBox(false).intersectsBox(box);
     }
 
-    public updateBox(force: boolean = false): THREE.Box3 {
+    public updateBox(force: boolean = false): Box3 {
         if (!this.box) {
-            this.box = new THREE.Box3();
+            this.box = new Box3();
         }
         if (force || this.context.time.frameCount != this._lastMatrixUpdateFrame) {
             const firstUpdate = this._lastMatrixUpdateFrame < 0;
@@ -77,8 +77,8 @@ export class BoxHelperComponent extends Behaviour {
     }
 
 
-    private _helper: THREE.LineSegments | null = null;
-    private _color: THREE.Color | null = null;
+    private _helper: LineSegments | null = null;
+    private _color: Color | null = null;
 
     awake(): void {
         this._helper = null;
@@ -86,7 +86,7 @@ export class BoxHelperComponent extends Behaviour {
         this.box = null;
     }
 
-    public showHelper(col: THREE.ColorRepresentation | null = null, force: boolean = false) {
+    public showHelper(col: ColorRepresentation | null = null, force: boolean = false) {
         if (!gizmos && !force) return;
         if (this._helper) {
             if (col)