@needle-tools/engine 2.37.0-pre → 2.38.0-pre

package/src/engine/engine_addressables.ts

@@ -5,7 +5,7 @@ import { Context } from "./engine_setup";
 import { Group, Object3D, Scene } from "three";
 import { processNewScripts } from "./engine_mainloop_utils";
 import { InstantiateEvent, registerPrefabProvider, syncInstantiate } from "./engine_networking_instantiate";
-import { download } from "./engine_web_api";
+import { download, hash } from "./engine_web_api";
 import { getLoader } from "./engine_gltf";
 import { SourceIdentifier } from "./engine_types";
 import { destroy, instantiate, InstantiateOptions } from "./engine_gameobject";
@@ -51,11 +51,11 @@ export class AssetReference {
 
     static getOrCreate(sourceId: SourceIdentifier, uri: string, context: Context): AssetReference {
         const fullPath = getPath(sourceId, uri);
-        if(debug) console.log("GetOrCreate Addressable from", sourceId, uri, "FinalPath=", fullPath);
+        if (debug) console.log("GetOrCreate Addressable from", sourceId, uri, "FinalPath=", fullPath);
         const addressables = context.addressables;
         const existing = addressables.findAssetReference(fullPath);
         if (existing) return existing;
-        const ref = new AssetReference(fullPath);
+        const ref = new AssetReference(fullPath, context.hash);
         addressables.registerAssetReference(ref);
         return ref;
     }
@@ -63,6 +63,7 @@ export class AssetReference {
     get asset(): any {
         return this._glbRoot ?? this._asset;
     }
+
     protected set asset(val: any) {
         this._asset = val;
     }
@@ -70,7 +71,7 @@ export class AssetReference {
     private _loading?: PromiseLike<any>;
 
     get uri(): string {
-        return this._uri!;
+        return this._uri;
     }
 
     get rawAsset(): any { return this._asset; }
@@ -80,11 +81,20 @@ export class AssetReference {
     private _uri: string;
     private _progressListeners: ProgressCallback[] = [];
 
+    private _hash?: string;
+    private _hashedUri: string;
+
     private _isLoadingRawBinary: boolean = false;
     private _rawBinary?: ArrayBuffer | null;
 
-    constructor(uri: string) {
+    constructor(uri: string, hash?: string) {
         this._uri = uri;
+        this._hash = hash;
+        if (uri.includes("?v="))
+            this._hashedUri = uri;
+        else
+            this._hashedUri = hash ? uri + "?v=" + hash : uri;
+
         registerPrefabProvider(this._uri, this.onResolvePrefab.bind(this));
     }
 
@@ -120,8 +130,8 @@ export class AssetReference {
         if (this._isLoadingRawBinary) return null;
         if (this._rawBinary !== undefined) return this._rawBinary;
         this._isLoadingRawBinary = true;
-        if (debug) console.log("Preload", this.uri);
-        const res = await download(this.uri, p => {
+        if (debug) console.log("Preload", this._hashedUri);
+        const res = await download(this._hashedUri, p => {
             this.raiseProgressEvent(p);
         });
         this._rawBinary = res?.buffer ?? null;
@@ -148,7 +158,7 @@ export class AssetReference {
         }
         else {
             if (debug) console.log("Load async", this.uri);
-            this._loading = getLoader().loadSync(context, this.uri, null, true, prog => {
+            this._loading = getLoader().loadSync(context, this._hashedUri, null, true, prog => {
                 this.raiseProgressEvent(prog);
             });
         }

package/src/engine/engine_element.ts

@@ -133,7 +133,8 @@ export class EngineElement extends HTMLElement implements INeedleEngineComponent
         if (srcAttributeValue) src = srcAttributeValue;
 
         const alias = this.getAttribute("alias");
-        this._context = new Context({ name: src, domElement: this, alias: alias });
+        const hash = this.getAttribute("hash");
+        this._context = new Context({ name: src, domElement: this, alias: alias, hash: hash ?? undefined });
         this._watcher = new EngineElementSourceFileWatcher(this.getAttribute("id") ?? alias ?? "", this._context);
 
         if (src && src.length > 0) {
@@ -234,7 +235,7 @@ export class EngineElement extends HTMLElement implements INeedleEngineComponent
     }
 
     static get observedAttributes() {
-        return ["src", "loadstart", "progress", "loadfinished", "dracoDecoderPath", "dracoDecoderType", "ktx2DecoderPath"];
+        return ["hash", "src", "loadstart", "progress", "loadfinished", "dracoDecoderPath", "dracoDecoderType", "ktx2DecoderPath"];
     }
 
     attributeChangedCallback(name: string, _oldValue: string, newValue: string) {

package/src/engine/engine_element_overlay.ts

@@ -73,11 +73,12 @@ export class AROverlayHandler {
             return element;
         }
         if (element.children) {
-            // @ts-ignore
-            for (const ch of element.children) {
+            for (let i = 0; i < element.children.length; i++) {
+                const ch = element.children[i] as HTMLElement;
                 if (!ch || !ch.classList) continue;
-                if (ch.classList.contains(arContainerClassName))
+                if (ch.classList.contains(arContainerClassName)) {
                     return ch;
+                }
             }
         }
 

package/src/engine/engine_input.ts

@@ -147,6 +147,10 @@ export class Input extends EventTarget {
         if (i >= this._mouseWheelChanged.length) return false;
         return this._mouseWheelChanged[i];
     }
+    getMouseWheelDeltaY(i: number = 0): number {
+        if (i >= this._mouseWheelDeltaY.length) return 0;
+        return this._mouseWheelDeltaY[i];
+    }
     getPointerEvent(i: number): Event | undefined {
         if (i >= this._pointerEvent.length) return undefined;
         return this._pointerEvent[i] ?? undefined;
@@ -169,6 +173,7 @@ export class Input extends EventTarget {
     private _pointerIds: number[] = [];
     private _pointerTypes: string[] = [""];
     private _mouseWheelChanged: boolean[] = [false];
+    private _mouseWheelDeltaY: number[] = [0];
     private _pointerEvent: Event[] = [];
 
     getKeyDown(): string | null {
@@ -269,11 +274,12 @@ export class Input extends EventTarget {
             this._pointerClick[i] = false;
         for (let i = 0; i < this._pointerDoubleClick.length; i++)
             this._pointerDoubleClick[i] = false;
-        for (const pt of this._pointerPositionsDelta) {
+        for (const pt of this._pointerPositionsDelta)
             pt.set(0, 0);
-        }
         for (let i = 0; i < this._mouseWheelChanged.length; i++)
             this._mouseWheelChanged[i] = false;
+        for (let i = 0; i < this._mouseWheelDeltaY.length; i++)
+            this._mouseWheelDeltaY[i] = 0;
     }
 
 
@@ -307,9 +313,12 @@ export class Input extends EventTarget {
         this.onDispatchEvent(InputEvents.KeyUp, new KeyEventArgs(evt));
     }
 
-    private onMouseWheel(_evt) {
+    private onMouseWheel(evt: WheelEvent) {
+        if (this._mouseWheelDeltaY.length <= 0) this._mouseWheelDeltaY.push(0);
         if (this._mouseWheelChanged.length <= 0) this._mouseWheelChanged.push(false);
         this._mouseWheelChanged[0] = true;
+        const current = this._mouseWheelDeltaY[0];
+        this._mouseWheelDeltaY[0] = current + evt.deltaY;
     }
 
     private onTouchMove(_evt) {

package/src/engine/engine_physics.ts

@@ -1,23 +1,19 @@
 import { BasicDepthPacking, Box3, BufferAttribute, BufferGeometry, Camera, Intersection, Layers, LineBasicMaterial, LineSegments, Matrix4, Mesh, NormalAnimationBlendMode, Object3D, Quaternion, Ray, Raycaster, Sphere, Vector2, Vector3 } from 'three'
 import { Context } from './engine_setup';
 import { getParam } from "./engine_utils"
-import { getWorldPosition, getWorldQuaternion, getWorldScale, setWorldPosition, setWorldPositionXYZ, setWorldQuaternionXYZW } from "./engine_three_utils"
+import { getWorldPosition, getWorldQuaternion, getWorldScale, setWorldPositionXYZ, setWorldQuaternionXYZW } from "./engine_three_utils"
 import {
     IComponent,
-    IGameObject,
     ICollider,
     IRigidbody,
     Collision,
-    ICollisionContext,
-    ContactPoint,
-    Vec3
+    ContactPoint
 } from './engine_types';
 import { InstancingUtil } from './engine_instancing';
 import { foreachComponent } from './engine_gameobject';
 
-import RAPIER, { ActiveEvents, Collider, ColliderDesc, EventQueue, RigidBody, TempContactManifold, World } from '@dimforge/rapier3d-compat';
-import { CollisionDetectionMode, RigidbodyConstraints } from '../engine/engine_physics.types';
-import { showBalloonWarning } from './debug/debug';
+import RAPIER, { ActiveEvents, Collider, ColliderDesc, EventQueue, RigidBody, RigidBodyType, World } from '@dimforge/rapier3d-compat';
+import { CollisionDetectionMode } from '../engine/engine_physics.types';
 export type Rapier = typeof RAPIER;
 
 
@@ -33,6 +29,8 @@ declare type PhysicsBody = {
 
 const $componentKey = Symbol("needle component");
 const $bodyKey = Symbol("physics body");
+const $colliderRigidbody = Symbol("rigidbody");
+// const $removed = Symbol("removed");
 
 export class RaycastOptions {
     ray: Ray | undefined = undefined;
@@ -209,6 +207,7 @@ export class Physics {
 
     private _tempPosition: Vector3 = new Vector3();
     private _tempQuaternion: Quaternion = new Quaternion();
+    private _tempScale: Vector3 = new Vector3();
     private _tempMatrix: Matrix4 = new Matrix4();
 
     private static _didLoadPhysicsEngine: boolean = false;
@@ -266,6 +265,14 @@ export class Physics {
         this.createCollider(collider, desc, center);
     }
 
+    addCapsuleCollider(collider: ICollider, center: Vector3, height: number, radius: number) {
+        const obj = collider.gameObject;
+        const scale = getWorldScale(obj, this._tempPosition);
+        if(debugPhysics) console.log("capsule scale", scale, height, radius);
+        const desc = ColliderDesc.capsule(height * .5 * scale.y - radius, radius * scale.x);
+        this.createCollider(collider, desc, center);
+    }
+
     addMeshCollider(collider: ICollider, mesh: Mesh, convex: boolean) {
         const geo = mesh.geometry;
         if (!geo) {
@@ -308,9 +315,10 @@ export class Physics {
             useExplicitMassProperties
         } = this.getRigidbody(collider, this._tempMatrix);
 
-        matrix.decompose(this._tempPosition, this._tempQuaternion, new Vector3());
+        matrix.decompose(this._tempPosition, this._tempQuaternion, this._tempScale);
+        getWorldScale(collider.gameObject, this._tempScale);
         if (center)
-            this._tempPosition.add(center);
+            this._tempPosition.add(center).multiply(this._tempScale);
         desc.setTranslation(this._tempPosition.x, this._tempPosition.y, this._tempPosition.z);
         desc.setRotation(this._tempQuaternion);
 
@@ -373,13 +381,15 @@ export class Physics {
 
         }
 
+        collider[$colliderRigidbody] = rigidBody;
+
         return { rigidBody: rigidBody, useExplicitMassProperties: useExplicitMassProperties };
     }
 
     removeBody(obj: IComponent) {
         const body = obj[$bodyKey];
         obj[$bodyKey] = null;
-        if (body) {
+        if (body && this.world) {
             const index = this.objects.findIndex(o => o === obj);
             if (index >= 0) {
                 const body = this.bodies[index];
@@ -387,20 +397,37 @@ export class Physics {
                 this.objects.splice(index, 1);
 
                 if (body instanceof Collider) {
-                    this.world?.removeCollider(body as Collider, true);
+                    const collider = body as Collider;
+                    this.world?.removeCollider(collider, true);
+
+                    // remove the rigidbody if it doesnt have colliders anymore
+                    const rb = collider.parent();
+                    if (rb && rb.numColliders() <= 0) {
+                        this.world?.removeRigidBody(rb);
+                    }
                 }
                 else if (body instanceof RigidBody) {
-                    this.world?.removeRigidBody(body as RigidBody);
+                    // TODO: running this code below causes a crash in rapier
+                    // const rb = body as RigidBody;
+                    // console.log("colliders", rb.numColliders())
+                    // for (let i = 0; i < rb.numColliders(); i++) {
+                    //     const col = rb.collider(i);
+                    //     this.world?.removeCollider(col, true);
+                    // }
+                    // console.log("colliders", rb.numColliders(), rb)
+                    // console.log(rb.handle, rb.userData);
+                    // if (rb.userData === undefined)
+                    //     this.world?.removeRigidBody(rb);
                 }
 
                 // check if we need to remove the rigidbody too
-                const col = obj as ICollider;
-                if (col.isCollider && col.attachedRigidbody) {
-                    const rb = col.attachedRigidbody[$bodyKey];
-                    if (rb && rb.numColliders() <= 0 && rb.world() === this.world) {
-                        this.world?.removeRigidBody(rb);
-                    }
-                }
+                // const col = obj as ICollider;
+                // if (col.isCollider && col.attachedRigidbody) {
+                //     const rb = col.attachedRigidbody[$bodyKey] as RigidBody;
+                //     if (rb && rb.numColliders() <= 0) {
+                //         // this.world?.removeRigidBody(rb);
+                //     }
+                // }
             }
         }
     }
@@ -526,10 +553,22 @@ export class Physics {
                 continue;
             }
 
+
             // sync
             const pos = body.translation();
-            setWorldPositionXYZ(obj.gameObject, pos.x, pos.y, pos.z);
             const rot = body.rotation();
+            // make sure to keep the collider offset
+            const center = obj["center"] as Vector3;
+            if (center && center.isVector3) {
+                this._tempQuaternion.set(rot.x, rot.y, rot.z, rot.w);
+                const offset = this._tempPosition.copy(center).applyQuaternion(this._tempQuaternion);
+                const scale = getWorldScale(obj.gameObject);
+                offset.multiply(scale);
+                pos.x -= offset.x;
+                pos.y -= offset.y;
+                pos.z -= offset.z;
+            }
+            setWorldPositionXYZ(obj.gameObject, pos.x, pos.y, pos.z);
             setWorldQuaternionXYZW(obj.gameObject, rot.x, rot.y, rot.z, rot.w);
         }
     }
@@ -542,13 +581,27 @@ export class Physics {
 
         const worldPosition = getWorldPosition(obj, this._tempPosition);
         const worldQuaternion = getWorldQuaternion(obj, this._tempQuaternion);
+        const type = body.bodyType();
+        switch (type) {
+            case RigidBodyType.Fixed:
+            case RigidBodyType.KinematicPositionBased:
+            case RigidBodyType.KinematicVelocityBased:
+                if (translation)
+                    body.setNextKinematicTranslation(worldPosition);
+                if (rotation)
+                    body.setNextKinematicRotation(worldQuaternion);
+                break;
+            default:
+                if (translation)
+                    body.setTranslation(worldPosition, false);
+                if (rotation)
+                    body.setRotation(worldQuaternion, false);
+                break;
+
+        }
+        body.wakeUp();
         // physicsBody.setBodyType(RAPIER.RigidBodyType.Fixed);
-        if (translation)
-            body.setTranslation(worldPosition, false);
-        if (rotation)
-            body.setRotation(worldQuaternion, false);
         // physicsBody.setLinvel(vel, false);
-        body.wakeUp();
 
         // update velocity
         // const pos = physicsBody.translation();
@@ -600,25 +653,6 @@ export class Physics {
 }
 
 
-export interface IColliderProvider {
-    getCollider(obj: Object3D): ICollider;
-}
-
-let colliderProvider: IColliderProvider | null = null;
-export function registerColliderProvider(prov: IColliderProvider) {
-    colliderProvider = prov;
-}
-
-class CollisionContext implements ICollisionContext {
-
-    getCollider(obj: Object3D<Event>): ICollider {
-        return colliderProvider!.getCollider(obj);
-    }
-
-}
-
-
-
 
 /** responsible of processing collision events for the component system */
 class PhysicsCollisionHandler {
@@ -642,7 +676,8 @@ class PhysicsCollisionHandler {
             const col2 = this.world!.getCollider(handle2);
             const colliderComponent1 = col1[$componentKey];
             const colliderComponent2 = col2[$componentKey];
-            // console.log("EVT", colliderComponent1.name, colliderComponent2.name, started);
+            if (debugCollisions)
+                console.log("EVT", colliderComponent1.name, colliderComponent2.name, started, col1, col2);
             if (colliderComponent1 && colliderComponent2) {
                 if (started) {
                     this.onCollisionStarted(colliderComponent1, col1, colliderComponent2, col2);
@@ -710,7 +745,7 @@ class PhysicsCollisionHandler {
         for (const active of this.activeTriggers) {
             const c = active.component;
             if (c.activeAndEnabled && c.onTriggerStay) {
-                const arg = active.collider;
+                const arg = active.otherCollider;
                 c.onTriggerStay(arg);
             }
         }

package/src/engine/engine_physics.types.ts

@@ -16,4 +16,13 @@ export enum RigidbodyConstraints {
   FreezeRotationZ = 64,
   FreezeRotation = 112,
   FreezeAll = 126,
+}
+
+
+export enum Axes {
+  None = 0,
+  X = 2,
+  Y = 4,
+  Z = 8,
+  All = ~0,
 }

package/src/engine/engine_setup.ts

@@ -58,6 +58,7 @@ export class ContextArgs {
 	alias: string | undefined | null = undefined;
 	domElement: HTMLElement | null;
 	renderer?: THREE.WebGLRenderer = undefined;
+	hash?: string;
 
 	constructor(domElement: HTMLElement | null) {
 		this.domElement = domElement ?? document.body;
@@ -70,7 +71,8 @@ export enum FrameEvent {
 	LateUpdate = 2,
 	OnBeforeRender = 3,
 	OnAfterRender = 4,
-	PhysicsStep = 10,
+	PrePhysicsStep = 9,
+	PostPhysicsStep = 10,
 }
 
 export enum XRSessionMode {
@@ -81,12 +83,12 @@ export enum XRSessionMode {
 export declare type OnBeforeRenderCallback = (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry, material: THREE.Material, group: THREE.Group) => void
 
 
-export function registerComponent(script : IComponent, context?: Context) {
-    if (!script) return;
-    const new_scripts = context?.new_scripts ?? Context.Current.new_scripts;
-    if (!new_scripts.includes(script)) {
-        new_scripts.push(script);
-    }
+export function registerComponent(script: IComponent, context?: Context) {
+	if (!script) return;
+	const new_scripts = context?.new_scripts ?? Context.Current.new_scripts;
+	if (!new_scripts.includes(script)) {
+		new_scripts.push(script);
+	}
 }
 
 export class Context {
@@ -105,13 +107,16 @@ export class Context {
 	alias: string | undefined | null;
 	isManagedExternally: boolean = false;
 
+	/** used to append to loaded assets */
+	hash?: string;
+
 	domElement: HTMLElement;
 	get resolutionScaleFactor() { return this._resolutionScaleFactor; }
 	/** use to scale the resolution up or down of the renderer. default is 1 */
-	set resolutionScaleFactor(val: number) { 
-		if(val === this._resolutionScaleFactor) return;
-		if(typeof val !== "number") return;
-		if(val <= 0) {
+	set resolutionScaleFactor(val: number) {
+		if (val === this._resolutionScaleFactor) return;
+		if (typeof val !== "number") return;
+		if (val <= 0) {
 			console.error("Invalid resolution scale factor", val);
 			return;
 		}
@@ -124,7 +129,9 @@ export class Context {
 	get domX(): number { return this.domElement.offsetLeft; }
 	get domY(): number { return this.domElement.offsetTop; }
 	get isInXR() { return this.renderer.xr?.isPresenting || false; }
-	xrSessionMode : XRSessionMode | undefined = undefined;
+	xrSessionMode: XRSessionMode | undefined = undefined;
+	get isInVR() { return this.xrSessionMode === XRSessionMode.ImmersiveVR; }
+	get isInAR() { return this.xrSessionMode === XRSessionMode.ImmersiveAR; }
 	get xrSession() { return this.renderer.xr?.getSession(); }
 	get arOverlayElement(): HTMLElement {
 		const el = this.domElement as any;
@@ -182,7 +189,7 @@ export class Context {
 	rendererData: RendererData;
 	addressables: Addressables;
 	lightmaps: ILightDataRegistry;
-	players : PlayerViewManager;
+	players: PlayerViewManager;
 
 	private _sizeChanged: boolean = false;
 	private _isCreated: boolean = false;
@@ -193,6 +200,7 @@ export class Context {
 		this.name = args?.name || "";
 		this.alias = args?.alias;
 		this.domElement = args?.domElement || document.body;
+		this.hash = args?.hash;
 		if (args?.renderer) {
 			this.renderer = args.renderer;
 			this.isManagedExternally = true;
@@ -232,7 +240,7 @@ export class Context {
 		this.lightmaps = new LightDataRegistry(this);
 		this.players = new PlayerViewManager(this);
 
-		window.addEventListener('resize', () => this._sizeChanged = true );
+		window.addEventListener('resize', () => this._sizeChanged = true);
 		const ro = new ResizeObserver(_ => this._sizeChanged = true);
 		ro.observe(this.domElement);
 	}
@@ -335,13 +343,13 @@ export class Context {
 	}
 
 	removeCamera(cam?: Camera | null) {
-		if(!cam) return;
+		if (!cam) return;
 		const index = this._cameraStack.indexOf(cam);
 		if (index >= 0) this._cameraStack.splice(index, 1);
 
 		if (this.mainCameraComponent === cam) {
 			this.mainCameraComponent = undefined;
-		
+
 			if (this._cameraStack.length > 0) {
 				const last = this._cameraStack[this._cameraStack.length - 1];
 				this.setCurrentCamera(last);
@@ -569,8 +577,9 @@ export class Context {
 			const physicsSteps = 1;
 			const dt = this.time.deltaTime / physicsSteps;
 			for (let i = 0; i < physicsSteps; i++) {
+				this.executeCoroutines(FrameEvent.PrePhysicsStep);
 				this.physics.step(dt);
-				this.executeCoroutines(FrameEvent.PhysicsStep);
+				this.executeCoroutines(FrameEvent.PostPhysicsStep);
 			}
 		}
 		catch (err) {

package/src/engine/engine_types.ts

@@ -173,7 +173,7 @@ export class ContactPoint {
 /// all info in here must be readonly because the object is only created once per started collision
 export class Collision {
 
-    private readonly contacts: ContactPoint[];
+    readonly contacts: ContactPoint[];
 
     constructor(obj: Object3D, otherCollider: ICollider, contacts: ContactPoint[]) {
         this.me = obj;
@@ -201,6 +201,7 @@ export class Collision {
         return this.collider?.attachedRigidbody;
     }
 
+    
 
     // private _normal?: Vector3;
     // get normal(): Vector3 {

package/src/engine-components/Animation.ts

@@ -112,6 +112,14 @@ export class Animation extends Behaviour {
         return this.actions?.find(a => a.getClip().name === name);
     }
 
+    get isPlaying() {
+        for (let i = 0; i < this._currentActions.length; i++) {
+            if (this._currentActions[i].isRunning())
+                return true;
+        }
+        return false;
+    }
+
     play(clipOrNumber: AnimationClip | number | string, options?: PlayOptions): Promise<AnimationAction> | void {
         this.init();
         if (!this.mixer) return;

package/src/engine-components/AnimatorController.ts

@@ -218,7 +218,7 @@ export class AnimatorController {
             if (!allConditionsAreMet) continue;
 
             if (debug && allConditionsAreMet) {
-                console.log("All conditions are met", transition);
+                // console.log("All conditions are met", transition);
             }
 
             // disable triggers
@@ -232,16 +232,16 @@ export class AnimatorController {
             if (action) {
                 const dur = state.motion.clip!.duration;
                 const normalizedTime = dur <= 0 ? 1 : action.time / dur;
-                if (!transition.hasExitTime
-                    || (normalizedTime >= transition.exitTime && action.time >= action.getClip().duration
-                    )
-                ) {
+                const makeTransition = transition.hasExitTime ? normalizedTime >= transition.exitTime : true;
+                // console.log(state.name, makeTransition, transition.hasExitTime, normalizedTime, transition.exitTime)
+                if (makeTransition) {
                     // if (transition.hasExitTime && transition.exitTime >= .9999) 
                     action.clampWhenFinished = true;
                     // else action.clampWhenFinished = false;
-                    if (debug) {
-                        console.log("transition to " + transition.destinationState, transition);
-                        console.log(action.time, transition.exitTime);
+                    if (debug) 
+                    {
+                        console.log("transition to " + transition.destinationState, transition, normalizedTime, transition.exitTime, transition.hasExitTime);
+                        // console.log(action.time, transition.exitTime);
                     }
                     this.transitionTo(transition.destinationState as State, transition.duration, transition.offset);
                     // use the first transition that matches all conditions and make the transition as soon as in range
@@ -252,7 +252,7 @@ export class AnimatorController {
                 this.transitionTo(transition.destinationState as State, transition.duration, transition.offset);
                 return;
             }
-            break;
+            // if none of the transitions can be made continue searching for another transition meeting the conditions
         }
 
         let didTriggerLooping = false;
@@ -376,7 +376,13 @@ export class AnimatorController {
     }
 
     private createAction(clip: AnimationClip) {
-        this._mixer.uncacheClip(clip);
+
+        // uncache clip causes issues when multiple states use the same clip
+        // this._mixer.uncacheClip(clip);
+        // instead only uncache the action when one already exists to make sure
+        // we get unique actions per state
+        const existing = this._mixer.existingAction(clip);
+        if (existing) this._mixer.uncacheAction(clip, this.animator?.gameObject);
 
         if (this.animator?.applyRootMotion) {
             if (!this.rootMotionHandler) {
@@ -387,7 +393,6 @@ export class AnimatorController {
             return this.rootMotionHandler.createClip(this._mixer, root, clip);
         }
         else {
-
             const action = this._mixer.clipAction(clip);
             return action;
         }