Needle Engine 3.10.2-beta

Files changed (4) hide show

src/engine/engine_input.ts +2 -2
src/engine-components/Renderer.ts +1 -1
src/engine-components/RendererLightmap.ts +13 -17
src/engine-components/webxr/WebXRController.ts +101 -80

src/engine/engine_input.ts CHANGED Viewed

@@ -529,10 +529,10 @@
         if (evt.pointerType === PointerType.Mouse) {
             const upTime = this._pointerUpTimestamp[evt.button];
             if (upTime > 0 && evt.source?.timeStamp !== undefined) {
-                const diff = (upTime - evt.source.timeStamp);
+                const diff = (evt.source.timeStamp - upTime);
                 // on android touch up and mouse up have the exact same value
                 // but on iOS they are not the same but a few milliseconds apart
-                if (diff < 30 && diff > 0) {
+                if (diff < 60 && diff >= 0) {
                     // we received an UP event for a touch, ignore this DOWN event
                     if (debug) console.log("Ignoring mouse.down for touch.up");
                     return;

src/engine-components/Renderer.ts CHANGED Viewed

@@ -317,9 +317,9 @@
         }
         return null;
     }
+    /** set undefined to return to default lightmap */
     public set lightmap(tex: Texture | null | undefined) {
         this._lightmapTextureOverride = tex;
-        // set undefined to return to default
         if (tex === undefined) {
             tex = this.context.lightmaps.tryGetLightmap(this.sourceId, this.lightmapIndex);
         }

src/engine-components/RendererLightmap.ts CHANGED Viewed

@@ -20,8 +20,8 @@
         }
     }
-    lightmapIndex: number = -1;
-    lightmapScaleOffset: THREE.Vector4 = new Vector4(1, 1, 0, 0);
+    private lightmapIndex: number = -1;
+    private lightmapScaleOffset: THREE.Vector4 = new Vector4(1, 1, 0, 0);
     private context: Context;
     private gameObject: Mesh;
@@ -50,8 +50,6 @@
         const uniforms = material["uniforms"];
         if (uniforms && uniforms.lightmap) {
             this.lightmapScaleOffsetUniform.value = this.lightmapScaleOffset;
-            this.lightmapUniform.value = this.lightmapTexture;
-            uniforms.lightmap = this.lightmapUniform;
             uniforms.lightmapScaleOffset = this.lightmapScaleOffsetUniform;
         }
     }
@@ -90,24 +88,22 @@
             this.gameObject.material.onBeforeCompile = this.onBeforeCompile;
         }
-        if (this.lightmapIndex >= 0) {
-            const lightmap = this.lightmapTexture;
+        if (this.lightmapIndex >= 0 && this.lightmapTexture) {
             const mat = this.gameObject.material as any;
-            if (mat && lightmap) {
-                if (!mat.uniforms) mat.uniforms = {};
-                mat.lightMap = lightmap;
-                mat.uniforms.lightmap = { value: lightmap };
+            if (mat) {
+                mat.lightMap = this.lightmapTexture;
+                mat.needsUpdate = true;
             }
         }
     }
     private onBeforeCompile = (shader: Shader, _) => {
-        if(debug) console.log("Lightmaps, before compile")
+        if (debug) console.log("Lightmaps, before compile", shader)
         //@ts-ignore
         shader.lightMapUv = "uv1";
         this.lightmapScaleOffsetUniform.value = this.lightmapScaleOffset;
         this.lightmapUniform.value = this.lightmapTexture;
-        shader.uniforms.lightmap = this.lightmapUniform;
+        // shader.uniforms.lightmap = this.lightmapUniform;
         shader.uniforms.lightmapScaleOffset = this.lightmapScaleOffsetUniform;
     }
@@ -124,7 +120,7 @@
                 }
                 `,
             fragmentShader: `
-                uniform sampler2D lightmap;
+                uniform sampler2D lightMap;
                 uniform float lightMapIntensity;
                 uniform vec4 lightmapScaleOffset;
                 varying vec2 vUv1;
@@ -137,11 +133,11 @@
                 void main() {
                     vec2 lUv = vUv1.xy * lightmapScaleOffset.xy + vec2(lightmapScaleOffset.z, (1. - (lightmapScaleOffset.y + lightmapScaleOffset.w)));
-                    vec4 lightMapTexel = texture2D( lightmap, lUv);
+                    vec4 lightMapTexel = texture2D( lightMap, lUv);
                     // The range of RGBM lightmaps goes from 0 to 34.49 (5^2.2) in linear space, and from 0 to 5 in gamma space.
-                    //lightMapTexel.rgb *= lightMapTexel.a * 8.; // no idea where that "8" comes from... heuristically derived
-                    //lightMapTexel.a = 1.;
-                    //lightMapTexel = conv_sRGBToLinear(lightMapTexel);
+                    // lightMapTexel.rgb *= lightMapTexel.a * 8.; // no idea where that "8" comes from... heuristically derived
+                    // lightMapTexel.a = 1.;
+                    // lightMapTexel = conv_sRGBToLinear(lightMapTexel);
                     // lightMapTexel.rgb = vec3(1.);
                     // gl_FragColor = vec4(vUv1.xy, 0, 1);

src/engine-components/webxr/WebXRController.ts CHANGED Viewed

@@ -18,6 +18,7 @@
 import { SyncedTransform } from "../SyncedTransform";
 import { UIRaycastUtils } from "../ui/RaycastUtils";
 import { WebXR } from "./WebXR";
+import { XRRig } from "./WebXRRig";
 const debug = getParam("debugwebxrcontroller");
@@ -165,7 +166,7 @@
     public grabbed: AttachedObject | null = null;
     public input: XRInputSource | null = null;
     public type: ControllerType = ControllerType.PhysicalDevice;
-    public showRaycastLine : boolean = true;
+    public showRaycastLine: boolean = true;
     get isUsingHands(): boolean {
         const r = this.input?.hand;
@@ -353,6 +354,33 @@
     rayRotation: Quaternion = new Quaternion();
+    private raycastUpdate(raycastLine: Line, wp: Vector3) {
+        const allowRaycastLineVisible = this.showRaycastLine && this.type !== ControllerType.Touch;
+        if (this.type === ControllerType.Touch) {
+            raycastLine.visible = false;
+        }
+        else if (this.isUsingHands) {
+            raycastLine.visible = !this.grabbed && allowRaycastLineVisible;
+            setWorldPosition(raycastLine, wp);
+            const jnts = this.hand!['joints'];
+            if (jnts) {
+                const wrist = jnts['wrist'];
+                if (wrist && this.grabbed && this.grabbed.isCloseGrab) {
+                    const wr = this.getWristQuaternion();
+                    if (wr)
+                        this.rayRotation.copy(wr);
+                    // this.rayRotation.slerp(wr, this.useSmoothing ? t * 2 : 1);
+                }
+            }
+            setWorldQuaternion(raycastLine, this.rayRotation);
+        }
+        else {
+            raycastLine.visible = allowRaycastLineVisible;
+            setWorldQuaternion(raycastLine, this.rayRotation);
+            setWorldPosition(raycastLine, wp);
+        }
+    }
     update(): void {
         // TODO: we should wait until we actually have models, this is just a workaround
@@ -381,30 +409,7 @@
         }
         if (this.raycastLine) {
-            const allowRaycastLineVisible = this.showRaycastLine && this.type !== ControllerType.Touch;
-            if (this.type === ControllerType.Touch) {
-                this.raycastLine.visible = false;
-            }
-            else if (this.isUsingHands) {
-                this.raycastLine.visible = !this.grabbed && allowRaycastLineVisible;
-                setWorldPosition(this.raycastLine, wp);
-                const jnts = this.hand!['joints'];
-                if (jnts) {
-                    const wrist = jnts['wrist'];
-                    if (wrist && this.grabbed && this.grabbed.isCloseGrab) {
-                        const wr = this.getWristQuaternion();
-                        if (wr)
-                            this.rayRotation.copy(wr);
-                        // this.rayRotation.slerp(wr, this.useSmoothing ? t * 2 : 1);
-                    }
-                }
-                setWorldQuaternion(this.raycastLine, this.rayRotation);
-            }
-            else {
-                this.raycastLine.visible = allowRaycastLineVisible;
-                setWorldQuaternion(this.raycastLine, this.rayRotation);
-                setWorldPosition(this.raycastLine, wp);
-            }
+            this.raycastUpdate(this.raycastLine, wp);
         }
         this.lastHit = this.updateLastHit();
@@ -420,8 +425,6 @@
         }
     }
-    private _pinchStartTime: number | undefined = undefined;
     onUpdate(session: XRSession) {
         this.lastHit = null;
@@ -446,52 +449,61 @@
         switch (this.input.handedness) {
             case "left":
-                const speedFactor = 3 * WebXRController.MovementSpeedFactor;
-                const powFactor = 2;
-                const speed = Mathf.clamp01(this.joystick.length() * 2);
+                this.movementUpdate(rig, buttons);
+                break;
-                const sideDir = this.joystick.x > 0 ? 1 : -1;
-                let side = Math.pow(this.joystick.x, powFactor);
-                side *= sideDir;
-                side *= speed;
+            case "right":
+                this.rotationUpdate(rig, buttons);
+                break;
+        }
+    }
-                const forwardDir = this.joystick.y > 0 ? 1 : -1;
-                let forward = Math.pow(this.joystick.y, powFactor);
-                forward *= forwardDir;
-                side *= speed;
+    private movementUpdate(rig: Object3D, buttons?: readonly GamepadButton[]) {
+        const speedFactor = 3 * WebXRController.MovementSpeedFactor;
+        const powFactor = 2;
+        const speed = Mathf.clamp01(this.joystick.length() * 2);
-                rig.getWorldQuaternion(this.worldRot);
-                this.movementVector.set(side, 0, forward);
-                this.movementVector.applyQuaternion(this.webXR.TransformOrientation);
-                this.movementVector.y = 0;
-                this.movementVector.applyQuaternion(this.worldRot);
-                this.movementVector.multiplyScalar(speedFactor * this.context.time.deltaTime);
-                rig.position.add(this.movementVector);
+        const sideDir = this.joystick.x > 0 ? 1 : -1;
+        let side = Math.pow(this.joystick.x, powFactor);
+        side *= sideDir;
+        side *= speed;
-                if (this.isUsingHands)
-                    this.runTeleport(rig, buttons);
-                break;
-            case "right":
-                const rotate = this.joystick.x;
-                const rotAbs = Math.abs(rotate);
-                if (rotAbs < 0.4) {
-                    this.didRotate = false;
-                }
-                else if (rotAbs > .5 && !this.didRotate) {
-                    const dir = rotate > 0 ? -1 : 1;
-                    rig.rotateY(Mathf.toRadians(30 * dir));
-                    this.didRotate = true;
-                }
+        const forwardDir = this.joystick.y > 0 ? 1 : -1;
+        let forward = Math.pow(this.joystick.y, powFactor);
+        forward *= forwardDir;
+        side *= speed;
-                this.runTeleport(rig, buttons);
+        rig.getWorldQuaternion(this.worldRot);
+        this.movementVector.set(side, 0, forward);
+        this.movementVector.applyQuaternion(this.webXR.TransformOrientation);
+        this.movementVector.y = 0;
+        this.movementVector.applyQuaternion(this.worldRot);
+        this.movementVector.multiplyScalar(speedFactor * this.context.time.deltaTime);
+        rig.position.add(this.movementVector);
-                break;
+        if (this.isUsingHands)
+            this.runTeleport(rig, buttons);
+    }
+    private rotationUpdate(rig: Object3D, buttons?: readonly GamepadButton[]) {
+        const rotate = this.joystick.x;
+        const rotAbs = Math.abs(rotate);
+        if (rotAbs < 0.4) {
+            this.didRotate = false;
         }
+        else if (rotAbs > .5 && !this.didRotate) {
+            const dir = rotate > 0 ? -1 : 1;
+            rig.rotateY(Mathf.toRadians(30 * dir));
+            this.didRotate = true;
+        }
+        this.runTeleport(rig, buttons);
     }
+    private _pinchStartTime: number | undefined = undefined;
-    private runTeleport(rig, buttons) {
+    private runTeleport(rig: Object3D, buttons?: readonly GamepadButton[]) {
         let teleport = -this.joystick.y;
         if (this.hand?.visible && !this.grabbed) {
             const pinched = this.handPointerModel.isPinched();
@@ -526,24 +538,10 @@
                         this.didChangeScale = true;
                         const rig = this.webXR.Rig;
                         if (rig) {
-                            if (!isInMiniatureMode) {
-                                isInMiniatureMode = true;
-                                doTeleport = true;
-                                newRigScale = .1;
-                                WebXRController.MovementSpeedFactor = newRigScale * 2;
-                                const cam = this.context.mainCamera as PerspectiveCamera;
-                                WebXRController.PreviousCameraFarDistance = cam.far;
-                                cam.far /= newRigScale;
-                            }
-                            else {
-                                isInMiniatureMode = false;
-                                rig.scale.set(1, 1, 1);
-                                newRigScale = 1;
-                                WebXRController.MovementSpeedFactor = 1;
-                                const cam = this.context.mainCamera as PerspectiveCamera;
-                                if (WebXRController.PreviousCameraFarDistance)
-                                    cam.far = WebXRController.PreviousCameraFarDistance;
-                            }
+                            let args = this.switchScale(rig, doTeleport, isInMiniatureMode, newRigScale);
+                            doTeleport = args.doTeleport;
+                            isInMiniatureMode = args.isInMiniatureMode;
+                            newRigScale = args.newRigScale;
                         }
                     }
                     else if (!btn.pressed)
@@ -575,10 +573,33 @@
         }
     }
     private isValidTeleportTarget(obj: Object3D): boolean {
         return GameObject.getComponentInParent(obj, TeleportTarget) != null;
     }
+    private switchScale(rig: Object3D, doTeleport: boolean, isInMiniatureMode: boolean, newRigScale: number | null) {
+        if (!isInMiniatureMode) {
+            isInMiniatureMode = true;
+            doTeleport = true;
+            newRigScale = .1;
+            WebXRController.MovementSpeedFactor = newRigScale * 2;
+            const cam = this.context.mainCamera as PerspectiveCamera;
+            WebXRController.PreviousCameraFarDistance = cam.far;
+            cam.far /= newRigScale;
+        }
+        else {
+            isInMiniatureMode = false;
+            rig.scale.set(1, 1, 1);
+            newRigScale = 1;
+            WebXRController.MovementSpeedFactor = 1;
+            const cam = this.context.mainCamera as PerspectiveCamera;
+            if (WebXRController.PreviousCameraFarDistance)
+                cam.far = WebXRController.PreviousCameraFarDistance;
+        }
+        return { doTeleport, isInMiniatureMode, newRigScale }
+    }
     private updateStick(inputSource: XRInputSource) {
         if (!inputSource || !inputSource.gamepad || inputSource.gamepad.axes?.length < 4) return;
         this.joystick.x = inputSource.gamepad.axes[2];