@needle-tools/engine 5.0.3 → 5.1.0-alpha.1

package/src/engine/xr/init.ts

@@ -0,0 +1,49 @@
+import { DeviceUtilities, setParamWithoutReload } from "../engine_utils.js";
+import { NeedleXRSession } from "./NeedleXRSession.js";
+
+/**
+ * Initialize XR subsystem. Called from `initEngine()`
+ */
+export function initXR() {
+    // Prewarm AR support check
+    NeedleXRSession.isARSupported();
+
+
+
+    if (DeviceUtilities.isiOS()) {
+
+        // Prefetch
+        const url = new URL("https://appclip.apple.com/id?p=tools.needle.launch-app.Clip");
+        url.searchParams.set("url", location.href);
+        const urlStr = url.toString();
+        fetch(urlStr, { method: "HEAD", mode: "no-cors" }).catch(() => {
+            // appclip prefetch - to get metadata faster on iOS devices, this seems to fix the double tap issue when opening the appclip for AR sessions.
+        });
+
+        try {
+            // We add the meta tag here to preload app clip card data for iOS.
+            const meta = window.top?.document.querySelector('meta[name="apple-itunes-app"]');
+            if(!meta) {
+                const metaTag = document.createElement("meta");
+                metaTag.name = "apple-itunes-app";
+                metaTag.content = "app-id=6757205152, app-clip-bundle-id=tools.needle.launch-app.Clip, app-clip-display=card";
+                window.top?.document.head.appendChild(metaTag);
+            }
+        }
+        catch (e) {
+            console.warn("Error adding apple-itunes-app meta tag for appclip support\n", e);
+        }
+
+        try {
+            // We preconnect to apple here to speed up the appclip meta request for the first click. NOT sure if necessary and working but can't hurt either?
+            const topWindow = window.top || window;
+            const preconnectMeta = topWindow.document.createElement("link");
+            preconnectMeta.rel = "preconnect";
+            preconnectMeta.href = url.toString();
+            topWindow.document.head.appendChild(preconnectMeta);
+        }
+        catch (e) {
+            console.warn("Error adding preconnect link for appclip.apple.com\n", e);
+        }
+    }
+}

package/src/engine-components/AnimationUtils.ts

@@ -1,29 +1,19 @@
 import { Object3D } from "three";
 
-const $objectAnimationKey = Symbol("objectIsAnimatedData");
+import { AnimationUtils } from "../engine/engine_animation.js";
 
 /** Internal method - This marks an object as being animated. Make sure to always call isAnimated=false if you stop animating the object
  * @param obj The object to mark
  * @param isAnimated Whether the object is animated or not
+ * @deprecated Use {@link AnimationUtils.setObjectAnimated} instead
  */
 export function setObjectAnimated(obj: Object3D, animatedBy: object, isAnimated: boolean) {
-    if (!obj) return;
-    if (obj[$objectAnimationKey] === undefined) {
-        if (!isAnimated) return;
-        obj[$objectAnimationKey] = new Set<object>();
-    }
-
-    const set = obj[$objectAnimationKey] as Set<object>;
-    if (isAnimated) {
-        set.add(animatedBy);
-    }
-    else if (set.has(animatedBy))
-        set.delete(animatedBy);
+    return AnimationUtils.setObjectAnimated(obj, animatedBy, isAnimated);
 }
 
-/** Get is the object is currently animated. Currently used by the Animator to check if a timeline animationtrack is actively animating an object */
+/** Get is the object is currently animated. Currently used by the Animator to check if a timeline animationtrack is actively animating an object 
+ * @deprecated Use {@link AnimationUtils.getObjectAnimated} instead
+*/
 export function getObjectAnimated(obj: Object3D): boolean {
-    if (!obj) return false;
-    const set = obj[$objectAnimationKey] as Set<object>;
-    return set !== undefined && set.size > 0;
+    return AnimationUtils.getObjectAnimated(obj) || false;
 }

package/src/engine-components/AnimatorController.ts

@@ -9,27 +9,13 @@ import { Context } from "../engine/engine_setup.js";
 import { isAnimationAction } from "../engine/engine_three_utils.js";
 import { TypeStore } from "../engine/engine_typestore.js";
 import { deepClone, getParam } from "../engine/engine_utils.js";
-import type { AnimatorControllerModel, Condition, State, Transition } from "../engine/extensions/NEEDLE_animator_controller_model.js";
+import type { AnimatorControllerModel, Condition, Parameter, State, Transition } from "../engine/extensions/NEEDLE_animator_controller_model.js";
 import { AnimatorConditionMode, AnimatorControllerParameterType, AnimatorStateInfo, createMotion, StateMachineBehaviour } from "../engine/extensions/NEEDLE_animator_controller_model.js";
 import type { Animator } from "./Animator.js";
 
 const debug = getParam("debuganimatorcontroller");
 const debugRootMotion = getParam("debugrootmotion");
 
-/**
- * Generates a hash code for a string
- * @param str - The string to hash
- * @returns A numeric hash value
- */
-function stringToHash(str): number {
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-        const char = str.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash;
-    }
-    return hash;
-}
 
 /**
  * Configuration options for creating an AnimatorController
@@ -43,15 +29,275 @@ declare type CreateAnimatorControllerOptions = {
     transitionDuration?: number,
 }
 
-/** 
+
+// #region AnimatorControllerBuilder
+
+/**
+ * Configuration for an animation state in the builder
+ */
+export declare type StateOptions = {
+    /** The animation clip for this state */
+    clip: AnimationClip;
+    /** Whether the animation should loop (default: false) */
+    loop?: boolean;
+    /** Base speed multiplier (default: 1) */
+    speed?: number;
+    /** Name of a float parameter to multiply with speed */
+    speedParameter?: string;
+    /** Normalized cycle offset 0-1 (default: 0) */
+    cycleOffset?: number;
+    /** Name of a float parameter to use as cycle offset */
+    cycleOffsetParameter?: string;
+}
+
+/**
+ * Configuration for a transition in the builder
+ */
+export declare type TransitionOptions = {
+    /** Duration of the crossfade in seconds (default: 0) */
+    duration?: number;
+    /** Normalized exit time 0-1 (default: 1). Only used when hasExitTime is true */
+    exitTime?: number;
+    /** Whether the transition waits for exitTime before transitioning (default: false) */
+    hasExitTime?: boolean;
+    /** Normalized offset into the destination state's animation (default: 0) */
+    offset?: number;
+    /** Whether duration is in seconds (true) or normalized (false) (default: false) */
+    hasFixedDuration?: boolean;
+}
+
+/** String condition modes for the builder, mapped to {@link AnimatorConditionMode} */
+export type ConditionMode = "if" | "ifNot" | "greater" | "less" | "equals" | "notEqual";
+
+function conditionModeToEnum(mode: ConditionMode): AnimatorConditionMode {
+    switch (mode) {
+        case "if": return AnimatorConditionMode.If;
+        case "ifNot": return AnimatorConditionMode.IfNot;
+        case "greater": return AnimatorConditionMode.Greater;
+        case "less": return AnimatorConditionMode.Less;
+        case "equals": return AnimatorConditionMode.Equals;
+        case "notEqual": return AnimatorConditionMode.NotEqual;
+    }
+}
+
+type BuilderTransition = {
+    to: string;
+    options: TransitionOptions;
+    conditions: Array<{ parameter: string; mode: ConditionMode; threshold: number }>;
+};
+
+type BuilderState = {
+    name: string;
+    options: StateOptions;
+    transitions: BuilderTransition[];
+};
+
+/**
+ * A fluent builder for creating {@link AnimatorController} instances from code.
+ *
+ * Use {@link AnimatorController.build} to create a new builder.
+ *
+ * @example
+ * ```ts
+ * const controller = AnimatorController.build("CharacterController")
+ *     .floatParameter("Speed", 0)
+ *     .triggerParameter("Jump")
+ *     .state("Idle", { clip: idleClip, loop: true })
+ *     .state("Walk", { clip: walkClip, loop: true })
+ *     .state("Jump", { clip: jumpClip })
+ *     .transition("Idle", "Walk", { duration: 0.25 })
+ *         .condition("Speed", "greater", 0.1)
+ *     .transition("Walk", "Idle", { duration: 0.25 })
+ *         .condition("Speed", "less", 0.1)
+ *     .transition("*", "Jump", { duration: 0.1 })
+ *         .condition("Jump", "if")
+ *     .transition("Jump", "Idle", { hasExitTime: true, exitTime: 0.9, duration: 0.25 })
+ *     .build();
+ * ```
+ *
+ * @category Animation and Sequencing
+ * @group Utilities
+ */
+export class AnimatorControllerBuilder {
+    private _name: string;
+    private _parameters: Parameter[] = [];
+    private _states: BuilderState[] = [];
+    private _anyStateTransitions: BuilderTransition[] = [];
+    private _defaultStateName: string | null = null;
+    private _lastTransition: BuilderTransition | null = null;
+
+    constructor(name?: string) {
+        this._name = name ?? "AnimatorController";
+    }
+
+    /** Adds a float parameter */
+    floatParameter(name: string, defaultValue: number = 0): this {
+        this._parameters.push({ name, hash: this._parameters.length, type: AnimatorControllerParameterType.Float, value: defaultValue });
+        return this;
+    }
+
+    /** Adds an integer parameter */
+    intParameter(name: string, defaultValue: number = 0): this {
+        this._parameters.push({ name, hash: this._parameters.length, type: AnimatorControllerParameterType.Int, value: defaultValue });
+        return this;
+    }
+
+    /** Adds a boolean parameter */
+    boolParameter(name: string, defaultValue: boolean = false): this {
+        this._parameters.push({ name, hash: this._parameters.length, type: AnimatorControllerParameterType.Bool, value: defaultValue });
+        return this;
+    }
+
+    /** Adds a trigger parameter */
+    triggerParameter(name: string): this {
+        this._parameters.push({ name, hash: this._parameters.length, type: AnimatorControllerParameterType.Trigger, value: false });
+        return this;
+    }
+
+    /**
+     * Adds a state to the controller. The first state added becomes the default state.
+     * @param name - Unique name for the state
+     * @param options - State configuration including clip, loop, speed
+     */
+    state(name: string, options: StateOptions): this {
+        this._states.push({ name, options, transitions: [] });
+        return this;
+    }
+
+    /**
+     * Adds a transition between two states.
+     * Use `"*"` as the source to create a transition from any state.
+     * Chain `.condition()` calls after this to add conditions.
+     * @param from - Source state name, or `"*"` for any-state transition
+     * @param to - Destination state name
+     * @param options - Transition configuration
+     */
+    transition(from: string, to: string, options?: TransitionOptions): this {
+        const t: BuilderTransition = { to, options: options ?? {}, conditions: [] };
+        if (from === "*") {
+            this._anyStateTransitions.push(t);
+        }
+        else {
+            const state = this._states.find(s => s.name === from);
+            if (!state) throw new Error(`AnimatorControllerBuilder: source state "${from}" not found. Add it with .state() first.`);
+            state.transitions.push(t);
+        }
+        this._lastTransition = t;
+        return this;
+    }
+
+    /**
+     * Adds a condition to the most recently added transition.
+     * Multiple conditions on the same transition are AND-ed together.
+     * @param parameter - Name of the parameter to evaluate
+     * @param mode - Condition mode: `"if"`, `"ifNot"`, `"greater"`, `"less"`, `"equals"`, `"notEqual"`
+     * @param threshold - Comparison threshold for numeric conditions (default: 0)
+     */
+    condition(parameter: string, mode: ConditionMode, threshold: number = 0): this {
+        if (!this._lastTransition) throw new Error("AnimatorControllerBuilder: .condition() must be called after .transition()");
+        this._lastTransition.conditions.push({ parameter, mode, threshold });
+        return this;
+    }
+
+    /**
+     * Sets which state is the default/entry state.
+     * If not called, the first added state is used.
+     * @param name - Name of the state
+     */
+    defaultState(name: string): this {
+        this._defaultStateName = name;
+        return this;
+    }
+
+    /**
+     * Builds and returns the {@link AnimatorController}.
+     * Resolves all state name references to indices.
+     */
+    build(): AnimatorController {
+        const stateIndexMap = new Map<string, number>();
+        this._states.forEach((s, i) => stateIndexMap.set(s.name, i));
+
+        let defaultStateIndex = 0;
+        if (this._defaultStateName !== null) {
+            const idx = stateIndexMap.get(this._defaultStateName);
+            if (idx === undefined) throw new Error(`AnimatorControllerBuilder: default state "${this._defaultStateName}" not found`);
+            defaultStateIndex = idx;
+        }
+
+        const resolveTransition = (t: BuilderTransition): Transition => {
+            const destIndex = stateIndexMap.get(t.to);
+            if (destIndex === undefined) throw new Error(`AnimatorControllerBuilder: transition target "${t.to}" not found`);
+            return {
+                exitTime: t.options.exitTime ?? 1,
+                hasExitTime: t.options.hasExitTime ?? false,
+                duration: t.options.duration ?? 0,
+                offset: t.options.offset ?? 0,
+                hasFixedDuration: t.options.hasFixedDuration ?? false,
+                destinationState: destIndex,
+                conditions: t.conditions.map(c => ({
+                    parameter: c.parameter,
+                    mode: conditionModeToEnum(c.mode),
+                    threshold: c.threshold,
+                })),
+            };
+        };
+
+        const states: State[] = this._states.map((s, index) => {
+            const transitions: Transition[] = s.transitions.map(resolveTransition);
+
+            // Replicate any-state transitions onto every state (except self-targeting)
+            for (const anyT of this._anyStateTransitions) {
+                const destIndex = stateIndexMap.get(anyT.to);
+                if (destIndex === index) continue;
+                transitions.push(resolveTransition(anyT));
+            }
+
+            return {
+                name: s.name,
+                hash: index,
+                motion: {
+                    name: s.options.clip.name,
+                    clip: s.options.clip,
+                    isLooping: s.options.loop ?? false,
+                },
+                transitions,
+                behaviours: [],
+                speed: s.options.speed,
+                speedParameter: s.options.speedParameter,
+                cycleOffset: s.options.cycleOffset,
+                cycleOffsetParameter: s.options.cycleOffsetParameter,
+            };
+        });
+
+        const model: AnimatorControllerModel = {
+            name: this._name,
+            guid: new InstantiateIdProvider(Date.now()).generateUUID(),
+            parameters: this._parameters,
+            layers: [{
+                name: "Base Layer",
+                stateMachine: {
+                    defaultState: defaultStateIndex,
+                    states,
+                }
+            }],
+        };
+
+        return new AnimatorController(model);
+    }
+}
+// #endregion
+
+// #region AnimatorController
+/**
  * Controls the playback of animations using a state machine architecture.
  * 
  * The AnimatorController manages animation states, transitions between states,
  * and parameters that affect those transitions. It is used by the {@link Animator}
  * component to control animation behavior on 3D models.
  * 
- * Use the static method {@link AnimatorController.createFromClips} to create
- * an animator controller from a set of animation clips.
+ * Use {@link AnimatorController.build} to fluently create a controller with parameters,
+ * states, transitions, and conditions. For simple sequential playback,
+ * use {@link AnimatorController.createFromClips}.
  * 
  * @category Animation and Sequencing
  * @group Utilities
@@ -119,6 +365,30 @@ export class AnimatorController {
         return controller;
     }
 
+    /**
+     * Creates a new {@link AnimatorControllerBuilder} for fluently constructing a controller with
+     * parameters, states, transitions, and conditions.
+     *
+     * @param name - Optional name for the controller
+     * @returns A new builder instance
+     *
+     * @example
+     * ```ts
+     * const ctrl = AnimatorController.build("MyController")
+     *     .floatParameter("Speed")
+     *     .state("Idle", { clip: idleClip, loop: true })
+     *     .state("Walk", { clip: walkClip, loop: true })
+     *     .transition("Idle", "Walk", { duration: 0.25 })
+     *         .condition("Speed", "greater", 0.1)
+     *     .transition("Walk", "Idle", { duration: 0.25 })
+     *         .condition("Speed", "less", 0.1)
+     *     .build();
+     * ```
+     */
+    static build(name?: string): AnimatorControllerBuilder {
+        return new AnimatorControllerBuilder(name);
+    }
+
     /**
      * Plays an animation state by name or hash.
      * 

package/src/engine-components/SeeThrough.ts

@@ -176,26 +176,6 @@ export class SeeThrough extends Behaviour {
     onEnable() {
         this._needsUpdate = true;
         this._renderer = null;
-        // SeeThroughUsdzExporterPlugin.components.push(this);
-    }
-
-    /**  @internal */
-    onDisable() {
-        // this._renderer?.forEach(r => {
-        //     const original = this.rendererMaterialsOriginal.get(r);
-        //     for (let i = 0; i < r.sharedMaterials.length; i++) {
-        //         const mat = r.sharedMaterials[i];
-        //         if (!mat) continue;
-        //         if (original && original[i]) {
-        //             r.sharedMaterials[i] = original[i];
-        //         }
-        //     }
-        //     this.rendererMaterials.delete(r);
-        //     this.rendererMaterialsOriginal.delete(r);
-        // });
-
-        // const index = SeeThroughUsdzExporterPlugin.components.indexOf(this);
-        // if (index !== -1) SeeThroughUsdzExporterPlugin.components.splice(index, 1);
     }
 
     /**
@@ -207,7 +187,6 @@ export class SeeThrough extends Behaviour {
         if (this._needsUpdate) {
             this._needsUpdate = false;
             this._renderer = this.gameObject.getComponentsInChildren(Renderer);
-
             // NOTE: instead of using the object's anchor (gameObject.worldPosition) we could also get the object's bounding box center:
             // getBoundingBox(this.gameObject); // < import { getBoundingBox } from "@needle-tools/engine";
             this.updateDirection();
@@ -216,12 +195,9 @@ export class SeeThrough extends Behaviour {
             this.updateDirection();
         }
 
-
-
         if (!this.autoUpdate) return;
         if (!this.referencePoint) return;
 
-
         const dot = this._referencePointDir.dot(this.context.mainCamera.worldForward);
         const shouldHide = dot > .2;
 
@@ -272,38 +248,10 @@ export class SeeThrough extends Behaviour {
                 renderer.gameObject.raycastAllowed = true;
             }
 
-            // if (!this.rendererMaterials.has(renderer)) {
-            //     const originalMaterials = new Array<Material>();
-            //     const clonedMaterials = new Array<MaterialWithState>();
-
-            //     // We clone the materials once and store them, so we can modify the opacity without affecting other objects using the same material. This could potentially be optimized further to re-use materials between renderers if multiple renderers use the same material.
-            //     for (let i = 0; i < renderer.sharedMaterials.length; i++) {
-            //         const mat = renderer.sharedMaterials[i];
-            //         if (!mat) continue;
-            //         originalMaterials.push(mat);
-            //         const matClone = mat.clone() as MaterialWithState;
-            //         // @ts-ignore
-            //         matClone.userData = mat.userData || {};
-            //         matClone.userData.seeThrough = {
-            //             initial: {
-            //                 opacity: matClone.opacity,
-            //                 transparent: matClone.transparent,
-            //                 alphaHash: matClone.alphaHash
-            //             }
-            //         }
-            //         clonedMaterials.push(matClone);
-            //         // renderer.sharedMaterials[i] = matClone;
-            //     }
-
-            //     this.rendererMaterials.set(renderer, clonedMaterials);
-            //     this.rendererMaterialsOriginal.set(renderer, originalMaterials);
-            // }
-
             const materials = renderer.sharedMaterials;// : this.rendererMaterials.get(renderer);
             if (!materials) return;
 
             const block = MaterialPropertyBlock.get(renderer.gameObject);
-
             const currentOpacity = (block.getOverride("opacity")?.value ?? materials[0].opacity ?? 1);
 
             let newAlpha = Mathf.lerp(currentOpacity, targetAlpha, duration <= 0 ? 1 : this.context.time.deltaTime / duration);;
@@ -315,72 +263,8 @@ export class SeeThrough extends Behaviour {
             block.setOverride("alphaHash", this.useAlphaHash);
             block.setOverride("opacity", newAlpha);
             block.setOverride("transparent", newAlpha >= 0.99999 ? false : !this.useAlphaHash);
-
-
-            // for (const mat of materials) {
-            //     if (!mat) continue;
-
-            //     let newAlpha = Mathf.lerp(mat.opacity, targetAlpha, duration <= 0 ? 1 : this.context.time.deltaTime / duration);;
-            //     if (newAlpha >= 0.99) newAlpha = 1;
-            //     else if (newAlpha <= 0.01) newAlpha = 0;
-
-
-            //     const wasTransparent = mat.transparent;
-            //     const wasAlphaHash = mat.alphaHash;
-            //     const previousOpacity = mat.opacity;
-
-            //     mat.alphaHash = this.useAlphaHash;
-
-            //     if (mat.userData && "seeThrough" in mat.userData) {
-            //         const initial = mat.userData.seeThrough.initial as MaterialState;
-            //         mat.opacity = initial.opacity * newAlpha;
-            //         mat.transparent = mat.opacity >= 1 ? initial.transparent : !this.useAlphaHash;
-            //     }
-            //     else {
-            //         mat.transparent = mat.opacity >= 1 ? false : !this.useAlphaHash;
-            //     }
-
-            //     if (wasTransparent !== mat.transparent 
-            //         || wasAlphaHash !== mat.alphaHash 
-            //         || mat.opacity !== previousOpacity // MeshPhysicsMaterial needs that and maybe other materials too...
-            //     ) {
-            //         mat.needsUpdate = true;
-            //     }
-            // }
         });
     }
 
 }
 
-
-;
-// class SeeThroughUsdzExporterPlugin implements IUSDExporterExtension {
-
-//     static readonly components: SeeThrough[] = [];
-
-//     get extensionName() {
-//         return "SeeThrough";
-//     }
-
-//     // onExportObject(object: Object3D<Object3DEventMap>, model: USDObject, context: USDZExporterContext) {
-//     //     const component = SeeThroughUsdzExporterPlugin.components.find(c => c.gameObject === object);
-//     //     if(!component) return;
-//     //     console.log("OH MY GOD SEE THROUGH USDZ EXPORTER", component, model);
-
-//     //     model.materialName = "AlphaHashMaterialInstance"; // we could make this unique per object if needed
-
-//     //     model.addEventListener("serialize", (writer, context) => {
-//     //         writer.appendLine(`# SeeThrough component on ${object.name}`);
-//     //     });
-//     // }
-
-// }
-
-// const seeThroughUsdzExporterPlugin = new SeeThroughUsdzExporterPlugin();
-
-// USDZExporter.beforeExport.addEventListener(args => {
-//     if (SeeThroughUsdzExporterPlugin.components.length === 0) return;
-//     if (args.exporter.extensions.includes(seeThroughUsdzExporterPlugin) === false) {
-//         args.exporter.extensions.push(seeThroughUsdzExporterPlugin);
-//     }
-// });

package/src/engine-components/SyncedRoom.ts

@@ -121,8 +121,36 @@ export class SyncedRoom extends Behaviour {
         if (debug) console.log(`SyncedRoom roomName:${this.roomName}, urlParamName:${this.urlParameterName}, joinRandomRoom:${this.joinRandomRoom}`);
     }
 
+    private _hasConnectedBefore: boolean = false;
+
     /** @internal */
     onEnable() {
+        if (this.createJoinButton) {
+            const button = this.createRoomButton();
+            this.context.menu.appendChild(button);
+        }
+        if (this.createViewOnlyButton) {
+            this.onEnableViewOnlyButton()
+        }
+
+        // On re-enable (after disable), reconnect immediately
+        if (this._hasConnectedBefore) {
+            this._connectToRoom();
+        }
+    }
+
+    /** @internal */
+    start() {
+        // Defer initial connection to start() so other components added in the same frame
+        // have time to register their listeners in awake/onEnable (e.g. PlayerSync)
+        if (!this._hasConnectedBefore) {
+            this._connectToRoom();
+        }
+    }
+
+    private _connectToRoom() {
+        this._hasConnectedBefore = true;
+
         // if the url contains a view parameter override room and join in view mode
         const viewId = utils.getParam(viewParamName);
         if (viewId && typeof viewId === "string" && viewId.length > 0) {
@@ -130,16 +158,7 @@ export class SyncedRoom extends Behaviour {
             this.context.connection.joinRoom(viewId, true);
             return;
         }
-        // If setup to join a random room
         this.tryJoinRoom();
-
-        if (this.createJoinButton) {
-            const button = this.createRoomButton();
-            this.context.menu.appendChild(button);
-        }
-        if (this.createViewOnlyButton) {
-            this.onEnableViewOnlyButton()
-        }
     }
 
     /** @internal */

package/src/engine-components/SyncedTransform.ts

@@ -145,7 +145,7 @@ export class SyncedTransform extends Behaviour {
      */
     public requestOwnership() {
         if (debug)
-            console.log("Request ownership");
+            console.log("[SyncedTransform] Request ownership");
         if (!this._model) {
             this._shouldRequestOwnership = true;
             this._needsUpdate = true;
@@ -189,7 +189,7 @@ export class SyncedTransform extends Behaviour {
     /** @internal */
     awake() {
         if (debug)
-            console.log("new instance", this.guid, this);
+            console.log("[SyncedTransform] new instance", this.guid, this);
         this._receivedDataBefore = false;
         this._targetPosition = new Vector3();
         this._targetRotation = new Quaternion();
@@ -245,7 +245,7 @@ export class SyncedTransform extends Behaviour {
         if (this.destroyed) return;
         if (typeof data.guid === "function" && data.guid() === this.guid) {
             if (debug)
-                console.log("new data", this.context.connection.connectionId, this.context.time.frameCount, this.guid, data);
+                console.log("[SyncedTransform] new data", this.context.connection.connectionId, this.context.time.frameCount, this.guid, data);
             this.receivedUpdate = true;
             this._receivedFastUpdate = data.fast();
             const transform = data.transform();
@@ -323,7 +323,7 @@ export class SyncedTransform extends Behaviour {
 
         if (!this.context.connection.isInRoom || !this._model) {
             if (debug)
-                console.log("no model or room", this.name, this.guid, this.context.connection.isInRoom);
+                console.log("[SyncedTransform] no model or room", this.name, this.guid, this.context.connection.isInRoom);
             return;
         }
 
@@ -409,7 +409,7 @@ export class SyncedTransform extends Behaviour {
         if (this.rb && this.overridePhysics) {
             if (this._wasKinematic !== undefined) {
                 if (debug)
-                    console.log("reset kinematic", this.rb.name, this._wasKinematic);
+                    console.log("[SyncedTransform] reset kinematic", this.rb.name, this._wasKinematic);
                 this.rb.isKinematic = this._wasKinematic;
             }