@needle-tools/engine 2.54.2-pre → 2.55.1-pre

package/src/engine-components/ParticleSystem.ts

@@ -153,6 +153,7 @@ class ParticleSystemEmissionOverTime extends BaseValueGenerator {
     }
 
     genValue(): number {
+        if (!this.system.emission.enabled) return 0;
         if (this.system.currentParticles >= this.system.maxParticles) return 0;
         // emission over time
         let emission = this.system.emission.rateOverTime.evaluate(this.system.time / this.system.duration, Math.random());
@@ -225,9 +226,15 @@ class TextureSheetAnimationBehaviour extends ParticleSystemBaseBehaviour {
 
 }
 
+const $particleRotation = Symbol("particleRotation")
+
 class RotationBehaviour extends ParticleSystemBaseBehaviour {
     type: string = "NeedleRotation"
 
+    initialize(particle: Particle) {
+        particle[$particleRotation] = Math.random();
+    }
+
     update(particle: Particle, delta: number) {
         if (particle.rotation === undefined) return;
 
@@ -235,7 +242,7 @@ class RotationBehaviour extends ParticleSystemBaseBehaviour {
 
         if (typeof particle.rotation === "number") {
             if (this.system.rotationOverLifetime.enabled) {
-                particle.rotation += this.system.rotationOverLifetime.evaluate(t) * delta;
+                particle.rotation += this.system.rotationOverLifetime.evaluate(t, particle[$particleRotation]) * delta;
             }
             else {
                 if (this.system.renderer.renderMode === ParticleSystemRenderMode.Billboard)
@@ -548,6 +555,8 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     private _state?: ParticlesEmissionState;
     emit(count: number) {
         if (this._particleSystem) {
+            // we need to call update the matrices etc e.g. if we call emit from a physics callback
+            this.onUpdate();
             count = Math.min(count, this.maxParticles - this.currentParticles);
             if (!this._state) this._state = new ParticlesEmissionState();
             this._state.waitEmiting = count;
@@ -768,6 +777,14 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     }
 
     onBeforeRender() {
+        this.onUpdate();
+        const dt = this.deltaTime;
+        this._batchSystem?.update(dt);
+        this._time += dt;
+        if (this._time > this.duration) this._time = 0;
+    }
+
+    private onUpdate() {
         if (this._bursts) {
             this.emission.bursts = this._bursts;
             delete this._bursts;
@@ -796,17 +813,12 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
             this._container.matrix.identity();
             this._container.matrix.scale(scale);
         }
-
         this.emission.system = this;
-        const dt = this.deltaTime;
         this._interface.update();
         this.shape.update(this, this.context, this.main.simulationSpace, this.gameObject);
         this.noise.update(this.context);
         this.inheritVelocity?.update(this.context);
         this.velocityOverLifetime.update(this);
-        this._batchSystem?.update(dt);
-        this._time += dt;
-        if (this._time > this.duration) this._time = 0;
     }
 
     private addSubParticleSystems() {

package/src/engine-components/ParticleSystemModules.ts

@@ -6,6 +6,11 @@ import { AnimationCurve } from "./AnimationCurve";
 import { Vec2, Vec3 } from "../engine/engine_types";
 import { Context } from "../engine/engine_setup";
 import { EmitterShape, FrameOverLife, Particle, ShapeJSON } from "three.quarks";
+import { createNoise4D, NoiseFunction4D } from 'simplex-noise';
+import { Gizmos } from "../engine/engine_gizmos";
+import { getParam } from "../engine/engine_utils";
+
+const debug = getParam("debugparticles");
 
 declare type Color4 = { r: number, g: number, b: number, a: number };
 declare type ColorKey = { time: number, color: Color4 };
@@ -457,10 +462,10 @@ export class SizeOverLifetimeModule {
 
 export class ShapeModule implements EmitterShape {
 
+    // Emittershape start
     get type(): string {
         return ParticleSystemShapeType[this.shapeType];
     }
-
     initialize(particle: Particle): void {
         this.getPosition();
         particle.position.copy(this._vector);
@@ -471,6 +476,7 @@ export class ShapeModule implements EmitterShape {
     clone(): EmitterShape {
         return new ShapeModule();
     }
+    // EmitterShape end
 
     @serializable()
     shapeType: ParticleSystemShapeType = ParticleSystemShapeType.Box;
@@ -574,16 +580,12 @@ export class ShapeModule implements EmitterShape {
                     this.randomConePoint(this.position, this.angle, radius, this.radiusThickness, this.arc, this.arcMode, this._vector);
                     break;
                 case ParticleSystemShapeType.Sphere:
-                    this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector);
-                    this._vector.x *= this.scale.x;
-                    this._vector.y *= this.scale.y;
-                    this._vector.z *= this.scale.z;
+                    this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector, this.scale);
                     break;
                 case ParticleSystemShapeType.Circle:
-                    this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector);
-                    this._vector.x *= this.scale.x;
-                    this._vector.y *= this.scale.y;
-                    this._vector.z *= 0;
+                    this._temp.copy(this.scale);
+                    this._temp.z = 0;
+                    this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector, this._temp);
                     break;
                 default:
                     this._vector.set(0, 0, 0);
@@ -600,6 +602,7 @@ export class ShapeModule implements EmitterShape {
             this._vector.applyEuler(this._rotation);
 
         if (isWorldSpace) {
+            this._vector.applyQuaternion(this.system.worldQuaternion);
             this._vector.add(this.system.worldPos);
         }
     }
@@ -607,7 +610,8 @@ export class ShapeModule implements EmitterShape {
 
 
     private _dir: Vector3 = new Vector3();
-    getDirection(position): Vector3 {
+
+    getDirection(pos: Vec3): Vector3 {
         if (!this.enabled) {
             this._dir.set(0, 0, 1);
             return this._dir;
@@ -623,10 +627,11 @@ export class ShapeModule implements EmitterShape {
                 break;
             case ParticleSystemShapeType.Circle:
             case ParticleSystemShapeType.Sphere:
-                const rx = position.x;
-                const ry = position.y;
-                const rz = position.z;
-                this._dir.set(rx, ry, rz).sub(this.position)
+                const rx = pos.x;
+                const ry = pos.y;
+                const rz = pos.z;
+                this._dir.set(rx, ry, rz)
+                this._dir.sub(this.position)
                 break;
             default:
                 this._dir.set(0, 0, 1);
@@ -640,7 +645,10 @@ export class ShapeModule implements EmitterShape {
         this._dir.normalize();
         this.spherizeDirection(this._dir, this.sphericalDirectionAmount);
         this.randomizeDirection(this._dir, this.randomDirectionAmount);
-        // Gizmos.DrawDirection(position, this._dir, 0xff0000, .5);
+        if (debug) {
+            Gizmos.DrawSphere(pos, .01, 0x883300, .5, true);
+            Gizmos.DrawDirection(pos, this._dir, 0x883300, .5, true);
+        }
         return this._dir;
     }
 
@@ -677,15 +685,15 @@ export class ShapeModule implements EmitterShape {
         dir.lerp(v, amount);
     }
 
-    private randomSpherePoint(pos: Vec3, radius: number, thickness: number, arc: number, vec: Vec3) {
+    private randomSpherePoint(pos: Vec3, radius: number, thickness: number, arc: number, vec: Vec3, scale: Vec3) {
         const u = Math.random();
         const v = Math.random();
         const theta = 2 * Math.PI * u * (arc / 360);
         const phi = Math.acos(2 * v - 1);
         const r = Mathf.lerp(1, 1 - (Math.pow(1 - Math.random(), Math.PI)), thickness) * (radius);
-        const x = pos.x + (-r * Math.sin(phi) * Math.cos(theta));
-        const y = pos.y + (r * Math.sin(phi) * Math.sin(theta));
-        const z = pos.z + (r * Math.cos(phi));
+        const x = pos.x + scale.x * (-r * Math.sin(phi) * Math.cos(theta));
+        const y = pos.y + scale.y * (r * Math.sin(phi) * Math.sin(theta));
+        const z = pos.z + scale.z * (r * Math.cos(phi));
         vec.x = x;
         vec.y = y;
         vec.z = z;
@@ -738,7 +746,6 @@ export class ShapeModule implements EmitterShape {
 
 
 
-import { createNoise4D, NoiseFunction4D } from 'simplex-noise';
 
 export class NoiseModule {
     @serializable()
@@ -1110,10 +1117,10 @@ export class RotationOverLifetimeModule {
     @serializable()
     zMultiplier!: number;
 
-    evaluate(t01: number): number {
+    evaluate(t01: number, t:number): number {
         if (!this.enabled) return 0;
         if (!this.separateAxes) {
-            const rot = this.z.evaluate(t01) * -1;
+            const rot = this.z.evaluate(t01, t) * -1;
             return rot;
         }
         return 0;

package/src/engine-components/Renderer.ts

@@ -22,6 +22,7 @@ const debugInstancing = getParam("debuginstancing");
 const debugProgressiveLoading = getParam("debugprogressive");
 const suppressProgressiveLoading = getParam("noprogressive");
 
+const showWireframe = getParam("wireframe");
 
 export enum ReflectionProbeUsage {
     Off = 0,
@@ -229,6 +230,12 @@ export class Renderer extends Behaviour implements IRenderer {
 
     allowProgressiveLoading: boolean = true;
 
+    registering() {
+        if (!this.enabled) {
+            this.setVisibility(false);
+        }
+    }
+
     awake() {
         this.clearInstancingState();
 
@@ -279,15 +286,20 @@ export class Renderer extends Behaviour implements IRenderer {
                 this._lightmaps = [];
 
                 if (type === "Mesh") {
-                    if (!this.gameObject["material"]?.isMeshBasicMaterial === true) {
+                    const mat = this.gameObject["material"];
+                    if (!mat?.isMeshBasicMaterial) {
                         const rm = new RendererLightmap(this.gameObject, this.context);// GameObject.addNewComponent(this.gameObject, RendererLightmap);
                         this._lightmaps.push(rm);
                         rm.init(this.lightmapIndex, this.lightmapScaleOffset, tex, debugLightmap);
                     }
+                    else {
+                        if (mat)
+                            console.warn("Lightmapping is not supported on MeshBasicMaterial", mat.name)
+                    }
                 }
                 // for multi materials we need to loop through children 
                 // and then we add a lightmap renderer component to each of them
-                else if (this.isMultiMaterialObject(this.gameObject)) {
+                else if (this.isMultiMaterialObject(this.gameObject) && this.sharedMaterials.length > 0) {
                     for (const child of this.gameObject.children) {
                         if (!child["material"]?.isMeshBasicMaterial) {
                             const rm = new RendererLightmap(child as GameObject, this.context);
@@ -303,6 +315,17 @@ export class Renderer extends Behaviour implements IRenderer {
             }
         }
 
+
+
+        if (showWireframe) {
+            for (let i = 0; i < this.sharedMaterials.length; i++) {
+                const mat: any = this.sharedMaterials[i];
+                if (mat) {
+                    mat.wireframe = true;
+                }
+            }
+        }
+
     }
 
     private _isInstancingEnabled: boolean = false;

package/src/engine-components/RigidBody.ts

@@ -359,26 +359,7 @@ export class Rigidbody extends Behaviour implements IRigidbody {
     /**d
      * @deprecated not used anymore
      */
-    public setBodyFromGameObject(_velocity: THREE.Vector3 | null | { x: number, y: number, z: number } = null) {
-        if (this.gameObject && !this.destroyed) {
-            // this.context.physics.updateBody(this);
-            // this._ignoreChange = true;
-            // const wp = this.worldPosition;
-            // this.body.position.set(wp.x, wp.y, wp.z);
-            // const wr = this.worldQuaternion;
-            // this.body.quaternion.set(wr.x, wr.y, wr.z, wr.w);
-
-            // if (velocity) {
-            //     Rigidbody.copyVector3.set(velocity.x, velocity.y, velocity.z);
-            //     this._smoothedVelocity.lerp(Rigidbody.copyVector3, this.context.time.deltaTime / .1);
-            //     const sm = this._smoothedVelocity;
-            //     this.body.velocity.x = sm.x;
-            //     this.body.velocity.y = sm.y;
-            //     this.body.velocity.z = sm.z;
-            // }
-            // this._ignoreChange = false;
-        }
-    }
+    public setBodyFromGameObject(_velocity: THREE.Vector3 | null | { x: number, y: number, z: number } = null) { }
 
 
 

package/src/engine-components/SyncedTransform.ts

@@ -268,7 +268,6 @@ export class SyncedTransform extends Behaviour {
             if (this.rb) {
                 this.rb.isKinematic = this._model.isOwned ?? false;
                 this.rb.setVelocity(0, 0, 0);
-                this.rb.setBodyFromGameObject();
             }
             return;
         }
@@ -288,7 +287,6 @@ export class SyncedTransform extends Behaviour {
                     console.log("RESET", this.name)
                 this.gameObject.position.set(0, 1, 0);
                 this.rb.setVelocity(0, 0, 0);
-                this.rb.setBodyFromGameObject();
             }
         }
 
@@ -300,7 +298,7 @@ export class SyncedTransform extends Behaviour {
                 console.log("send update", this.context.connection.connectionId, this.guid, this.gameObject.name, this.gameObject.guid);
 
             if (this.overridePhysics && this.rb) {
-                this.rb.setBodyFromGameObject();
+                // this.rb.setBodyFromGameObject();
             }
 
             this._needsUpdate = false;

package/src/engine-components/VideoPlayer.ts

@@ -73,37 +73,37 @@ export class VideoPlayer extends Behaviour {
     private _playbackSpeed: number = 1;
     @serializable()
     get playbackSpeed(): number {
-        return this.videoElement?.playbackRate ?? this._playbackSpeed;
+        return this._videoElement?.playbackRate ?? this._playbackSpeed;
     }
     set playbackSpeed(val: number) {
         this._playbackSpeed = val;
-        if (this.videoElement)
-            this.videoElement.playbackRate = val;
+        if (this._videoElement)
+            this._videoElement.playbackRate = val;
     }
 
     private _isLooping: boolean = false;
     get isLooping(): boolean {
-        return this.videoElement?.loop ?? this._isLooping;
+        return this._videoElement?.loop ?? this._isLooping;
     }
     @serializable()
     set isLooping(val: boolean) {
         this._isLooping = val;
-        if (this.videoElement)
-            this.videoElement.loop = val;
+        if (this._videoElement)
+            this._videoElement.loop = val;
     }
 
     get currentTime(): number {
-        return this.videoElement?.currentTime ?? this.time;
+        return this._videoElement?.currentTime ?? this.time;
     }
     set currentTime(val: number) {
-        if (this.videoElement) {
-            this.videoElement.currentTime = val;
+        if (this._videoElement) {
+            this._videoElement.currentTime = val;
         }
         else this.time = val;
     }
 
     get isPlaying(): boolean {
-        const video = this.videoElement;
+        const video = this._videoElement;
         if (video) {
             return video.currentTime > 0 && !video.paused && !video.ended
                 && video.readyState > video.HAVE_CURRENT_DATA;
@@ -112,13 +112,13 @@ export class VideoPlayer extends Behaviour {
     }
 
     get crossOrigin(): string | null {
-        return this.videoElement?.crossOrigin ?? this._crossOrigin;
+        return this._videoElement?.crossOrigin ?? this._crossOrigin;
     }
     set crossOrigin(val: string | null) {
         this._crossOrigin = val;
-        if (this.videoElement) {
-            if (val !== null) this.videoElement.setAttribute("crossorigin", val);
-            else this.videoElement.removeAttribute("crossorigin");
+        if (this._videoElement) {
+            if (val !== null) this._videoElement.setAttribute("crossorigin", val);
+            else this._videoElement.removeAttribute("crossorigin");
         }
     }
 
@@ -126,6 +126,10 @@ export class VideoPlayer extends Behaviour {
         return this._videoTexture;
     }
 
+    get videoElement() {
+        return this._videoElement;
+    }
+
     private _crossOrigin: string | null = "anonymous";
 
     private audioOutputMode: VideoAudioOutputMode = VideoAudioOutputMode.AudioSource;
@@ -134,7 +138,7 @@ export class VideoPlayer extends Behaviour {
     private clip?: string | MediaStream | null = null;
     private url?: string | null = null;
 
-    private videoElement: HTMLVideoElement | null = null;
+    private _videoElement: HTMLVideoElement | null = null;
     private _videoTexture: THREE.VideoTexture | null = null;
     private videoMaterial: Material | null = null;
 
@@ -144,12 +148,12 @@ export class VideoPlayer extends Behaviour {
     setVideo(video: MediaStream) {
         this.clip = video;
         this.source = VideoSource.VideoClip;
-        if (!this.videoElement) this.create(true);
+        if (!this._videoElement) this.create(true);
         else {
             // TODO: how to prevent interruption error when another video is already playing
-            this.videoElement.srcObject = video;
+            this._videoElement.srcObject = video;
             if (this._isPlaying)
-                this.videoElement.play();
+                this._videoElement.play();
             this.updateAspect();
         }
     }
@@ -160,9 +164,9 @@ export class VideoPlayer extends Behaviour {
         this.url = url;
         this.source = VideoSource.Url;
         if (debug) console.log("set url", url);
-        if (!this.videoElement) this.create(true);
+        if (!this._videoElement) this.create(true);
         else {
-            this.videoElement.src = url;
+            this._videoElement.src = url;
             if (this._isPlaying) {
                 this.stop();
                 this.play();
@@ -201,9 +205,9 @@ export class VideoPlayer extends Behaviour {
     }
 
     onDestroy(): void {
-        if (this.videoElement) {
-            this.videoElement.parentElement?.removeChild(this.videoElement);
-            this.videoElement = null;
+        if (this._videoElement) {
+            this._videoElement.parentElement?.removeChild(this._videoElement);
+            this._videoElement = null;
         }
         if (this._videoTexture) {
             this._videoTexture.dispose();
@@ -231,27 +235,27 @@ export class VideoPlayer extends Behaviour {
     }
 
     play() {
-        if (!this.videoElement) return;
-        if (this._isPlaying && !this.videoElement?.ended && !this.videoElement?.paused) return;
+        if (!this._videoElement) return;
+        if (this._isPlaying && !this._videoElement?.ended && !this._videoElement?.paused) return;
         this._isPlaying = true;
-        if (!this._receivedInput) this.videoElement.muted = true;
+        if (!this._receivedInput) this._videoElement.muted = true;
         this.updateVideoElementSettings();
-        this.videoElement?.play().catch(err => {
+        this._videoElement?.play().catch(err => {
             console.warn(err);
         });
-        if (debug) console.log("play", this.videoElement);
+        if (debug) console.log("play", this._videoElement);
     }
 
     stop() {
         this._isPlaying = false;
-        if (!this.videoElement) return;
-        this.videoElement.currentTime = 0;
-        this.videoElement.pause();
+        if (!this._videoElement) return;
+        this._videoElement.currentTime = 0;
+        this._videoElement.pause();
     }
 
     pause(): void {
         this._isPlaying = false;
-        this.videoElement?.pause();
+        this._videoElement?.pause();
     }
 
 
@@ -270,23 +274,23 @@ export class VideoPlayer extends Behaviour {
 
         // console.log(src, this);
 
-        if (!this.videoElement) {
-            this.videoElement = this.createVideoElement();
-            this.context.domElement?.prepend(this.videoElement);
+        if (!this._videoElement) {
+            this._videoElement = this.createVideoElement();
+            this.context.domElement?.prepend(this._videoElement);
             // hide it because otherwise it would overlay the website with default css
             this.updateVideoElementStyles();
         }
         if (typeof src === "string") {
-            this.videoElement.src = src;
-            const str = this.videoElement["captureStream"]?.call(this.videoElement);
+            this._videoElement.src = src;
+            const str = this._videoElement["captureStream"]?.call(this._videoElement);
             this.clip = str;
         }
         else
-            this.videoElement.srcObject = src;
+            this._videoElement.srcObject = src;
 
 
         if (!this._videoTexture)
-            this._videoTexture = new THREE.VideoTexture(this.videoElement);
+            this._videoTexture = new THREE.VideoTexture(this._videoElement);
         this._videoTexture.flipY = false;
         this._videoTexture.encoding = THREE.sRGBEncoding;
         this.handleBeginPlaying(playAutomatically);
@@ -327,7 +331,7 @@ export class VideoPlayer extends Behaviour {
 
     private handleBeginPlaying(playAutomatically: boolean) {
         if (!this.enabled) return;
-        if (!this.videoElement) return;
+        if (!this._videoElement) return;
 
         this._targetObjects.length = 0;
 
@@ -385,24 +389,24 @@ export class VideoPlayer extends Behaviour {
     }
 
     private updateVideoElementSettings() {
-        if (!this.videoElement) return;
-        this.videoElement.loop = this._isLooping;
-        this.videoElement.currentTime = this.currentTime;
-        this.videoElement.playbackRate = this._playbackSpeed;
+        if (!this._videoElement) return;
+        this._videoElement.loop = this._isLooping;
+        this._videoElement.currentTime = this.currentTime;
+        this._videoElement.playbackRate = this._playbackSpeed;
         // dont open in fullscreen on ios
-        this.videoElement.playsInline = true;
-        this.videoElement.muted = !this._receivedInput && this.audioOutputMode !== VideoAudioOutputMode.None;
+        this._videoElement.playsInline = true;
+        this._videoElement.muted = !this._receivedInput && this.audioOutputMode !== VideoAudioOutputMode.None;
         if (this.playOnAwake || this.playOnEnable)
-            this.videoElement.autoplay = true;
+            this._videoElement.autoplay = true;
     }
 
     private updateVideoElementStyles() {
-        if (!this.videoElement) return;
+        if (!this._videoElement) return;
         // set style here so preview frame is rendered
         // set display and selectable because otherwise is interfers with input/focus e.g. breaks orbit control
-        this.videoElement.style.userSelect = "none";
-        this.videoElement.style.visibility = "hidden";
-        this.videoElement.style.display = "none";
+        this._videoElement.style.userSelect = "none";
+        this._videoElement.style.visibility = "hidden";
+        this._videoElement.style.display = "none";
         this.updateAspect();
     }
 

package/src/engine-components/WebARSessionRoot.ts

@@ -92,6 +92,9 @@ export class WebARSessionRoot extends Behaviour {
     placeAt(rig: Object3D | null, mat: Matrix4) {
         if (!this._placementPose) this._placementPose = new Matrix4();
         this._placementPose.copy(mat);
+        // apply session root offset
+        const invertedSessionRoot = this.gameObject.matrixWorld.clone().invert();
+        this._placementPose.premultiply(invertedSessionRoot);
         if (rig) {
 
             if (this.invertForward) {
@@ -146,9 +149,11 @@ export class WebARSessionRoot extends Behaviour {
         if (!rig || !this._placementPose) {
             return;
         }
+        // Capture the rig position before the first time we move it during a session
         if (!this._rigStartPose) {
             this._rigStartPose = rig.matrix.clone();
         }
+        // we apply the transform to the rig because we want to move the user's position for easy networking
         rig.matrixAutoUpdate = false;
         rig.matrix.multiplyMatrices(new Matrix4().makeScale(scale, scale, scale), this._placementPose);
         rig.matrix.decompose(rig.position, rig.quaternion, rig.scale);

package/src/engine-components/WebXR.ts

@@ -143,6 +143,7 @@ export class WebXR extends Behaviour {
         return this.rig;
     }
 
+
     private controllers: WebXRController[] = [];
     public get Controllers(): WebXRController[] {
         return this.controllers;
@@ -249,17 +250,21 @@ export class WebXR extends Behaviour {
         // TODO: figure out why screen is black if we enable the code written here
         // const referenceSpace = renderer.xr.getReferenceSpace();
         const session = this.context.renderer.xr.getSession();
+        
 
         if (session) {
             const pose = frame.getViewerPose(this.context.renderer.xr.getReferenceSpace());
+            if(!pose) return;
             this._currentHeadPose = pose;
-            if (!pose) return; // e.g. if user is not wearing headset
             const transform: XRRigidTransform = pose?.transform;
-
             if (transform) {
                 this._transformOrientation.set(transform.orientation.x, transform.orientation.y, transform.orientation.z, transform.orientation.w);
             }
 
+            if (WebXR._isInXr === false && session) {
+                this.onEnterXR(session, frame);
+            }
+
             for (const ctrl of this.controllers) {
                 ctrl.onUpdate(session);
             }
@@ -269,9 +274,6 @@ export class WebXR extends Behaviour {
             }
         }
 
-        if (WebXR._isInXr === false && session) {
-            this.onEnterXR(session, frame);
-        }
         WebXR.events.dispatchEvent({ type: WebXREvent.XRUpdate, frame: frame, xr: this.context.renderer.xr, rig: this.rig });
     }
 
@@ -329,7 +331,7 @@ export class WebXR extends Behaviour {
             if (xrRig) {
                 // make it match unity forward
                 this.rig = xrRig.gameObject;
-                this.rig.rotateY(Math.PI);
+                // this.rig.rotateY(Math.PI);
                 // this.rig.position.copy(existing.worldPosition);
                 // this.rig.quaternion.premultiply(existing.worldQuaternion);
             }
@@ -577,7 +579,7 @@ export class WebAR {
             this.reticleParent.name = "AR Reticle Parent";
             this.reticleParent.matrixAutoUpdate = false;
             this.reticleParent.add(this.reticle);
-            this.reticleParent.matrix.copy(this.sessionRoot.gameObject.matrixWorld);
+            // this.reticleParent.matrix.copy(this.sessionRoot.gameObject.matrixWorld);
 
             if (this.webxr.scene) {
                 this.context.scene.add(this.reticleParent);
@@ -632,11 +634,11 @@ export class WebAR {
                 this.didPlaceARSessionRoot = true;
                 const rig = this.webxr.Rig;
                 const placementMatrix = arPlacementWithoutHitTestMatrix.clone();
-                if (rig) {
-                    const positionFromRig = new Vector3(0, 0, 0).add(rig.position).divideScalar(this.sessionRoot?.arScale ?? 1);
-                    placementMatrix.multiply(new Matrix4().makeTranslation(positionFromRig.x, positionFromRig.y, positionFromRig.z));
-                    // placementMatrix.setPosition(positionFromRig);
-                }
+                // if (rig) {
+                //     const positionFromRig = new Vector3(0, 0, 0).add(rig.position).divideScalar(this.sessionRoot?.arScale ?? 1);
+                //     placementMatrix.multiply(new Matrix4().makeTranslation(positionFromRig.x, positionFromRig.y, positionFromRig.z));
+                //     // placementMatrix.setPosition(positionFromRig);
+                // }
                 this.sessionRoot?.placeAt(rig, placementMatrix);
             }
             return;
@@ -676,4 +678,4 @@ export class WebAR {
     }
 }
 
-const arPlacementWithoutHitTestMatrix = new Matrix4().identity().makeTranslation(0, -0.5, 0);
+const arPlacementWithoutHitTestMatrix = new Matrix4().identity().makeTranslation(0, 0, 0);