@3dsource/angular-unreal-module 0.0.132 → 0.0.133

package/fesm2022/3dsource-angular-unreal-module.mjs

@@ -4493,6 +4493,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
         }], ctorParameters: () => [] });
 
 const INITIAL_FINGER_IDS = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0];
+const UNSIGNED_RANGE = 65536;
+const UNSIGNED_OUT_OF_RANGE = 65535;
+const SIGNED_RANGE = 32767;
+const WHEEL_DELTA_SCALE = -120;
+const RESIZE_DEBOUNCE_MS = 300;
+const FUNCTION_KEY_MIN = 112;
+const FUNCTION_KEY_MAX = 123;
+const TAB_KEY_CODE = 9;
 class InputService extends SubService {
     constructor() {
         super();
@@ -4522,19 +4530,14 @@ class InputService extends SubService {
         this.deactivatedVideoTrigger$ = NEVER;
         this.normalizeAndQuantizeUnsigned = (_x, _y) => ({
             inRange: false,
-            x: 65535,
-            y: 65535,
+            x: UNSIGNED_OUT_OF_RANGE,
+            y: UNSIGNED_OUT_OF_RANGE,
         });
         this.normalizeAndQuantizeSigned = (_x, _y) => ({ x: 0, y: 0 });
         this.videoBoundingRect = new DOMRect(0, 0, 1, 1);
         this.fingerIds = new Map();
         this.maxByteValue = 255;
         this.fingers = [...INITIAL_FINGER_IDS];
-        // Captured straight from normalizeCoordinates inside the emit* methods —
-        // i.e., the exact quantized values that just went out over the data channel.
-        // Resending these on resize avoids any re-transformation through stale
-        // offsetParams or container dimensions.
-        this.lastNormalizedCoordinates = null;
         this.offsetParams = {
             scaleX: 1,
             scaleY: 1,
@@ -4573,26 +4576,11 @@ class InputService extends SubService {
         this.fingerIds.clear();
         this.fingers = [...INITIAL_FINGER_IDS];
         merge(fromResizeObserver(video), this.actions$.pipe(ofType(videoAdaptedToContainer)))
-            .pipe(debounceTime$1(300), takeUntil$1(this.deactivatedVideoTrigger$))
-            .subscribe(() => {
-            this.setupNormalizeAndQuantize(video);
-            this.resendLastMousePosition();
-        });
+            .pipe(debounceTime$1(RESIZE_DEBOUNCE_MS), takeUntil$1(this.deactivatedVideoTrigger$))
+            .subscribe(() => this.setupNormalizeAndQuantize(video));
         this.setupNormalizeAndQuantize(video);
         this.registerInputs(video);
     }
-    resendLastMousePosition() {
-        const last = this.lastNormalizedCoordinates;
-        if (!last)
-            return;
-        const data = new DataView(new ArrayBuffer(9));
-        data.setUint8(0, MessageType.MouseMove);
-        data.setUint16(1, last.x, true);
-        data.setUint16(3, last.y, true);
-        data.setInt16(5, 0, true);
-        data.setInt16(7, 0, true);
-        this.sendInputData(data.buffer);
-    }
     /**
      * We use `object-fit: cover` on the video element. Since the video can have
      * a different aspect ratio from its container (and potentially be larger),
@@ -4610,18 +4598,13 @@ class InputService extends SubService {
             videoWidth,
             videoHeight,
         });
-        // Compute aspect ratios
         const containerRatio = width / height;
         const videoRatio = videoWidth / videoHeight;
-        // Determine how much to scale the video to fit the container (cover mode)
         const scale = videoRatio > containerRatio ? height / videoHeight : width / videoWidth;
-        // Calculate the displayed (scaled) dimensions of the video
         const scaledWidth = videoWidth * scale;
         const scaledHeight = videoHeight * scale;
-        // Offsets in x/y directions (like "padding") once the video is scaled
         const offsetByX = (width - scaledWidth) / 2;
         const offsetByY = (height - scaledHeight) / 2;
-        // Scale factors for coordinate transformation from container space to video space
         const scaleX = width / scaledWidth;
         const scaleY = height / scaledHeight;
         return {
@@ -4637,14 +4620,13 @@ class InputService extends SubService {
         this.videoBoundingRect = videoElement.getBoundingClientRect();
         this.offsetParams = this.getObjectFitOffset(videoElement);
         // Unsigned XY positions are the ratio (0.0..1.0) along a viewport axis,
-        // quantized into an uint16 (0..65536).
+        // quantized into a uint16 (0..65536).
         // Signed XY deltas are the ratio (-1.0..1.0) along a viewport axis,
         // quantized into an int16 (-32767..32767).
-        // This allows the browser viewport and client viewport to have a different
-        // size.
-        // Hack: Currently, we set an out-of-range position to an extreme (65535)
-        // as we can't yet accurately detect mouse enter and leave events
-        // precisely inside a video with an aspect ratio which causes mattes.
+        // This allows the browser viewport and client viewport to have different sizes.
+        // Hack: an out-of-range position becomes UNSIGNED_OUT_OF_RANGE because we
+        // can't yet accurately detect mouse enter/leave precisely inside a video
+        // with an aspect ratio that causes mattes.
         this.normalizeAndQuantizeUnsigned = (x, y) => {
             const normalizedX = x / videoElement.clientWidth;
             const normalizedY = y / videoElement.clientHeight;
@@ -4654,25 +4636,22 @@ class InputService extends SubService {
                 normalizedY > 1.0) {
                 return {
                     inRange: false,
-                    x: 65535,
-                    y: 65535,
-                };
-            }
-            else {
-                return {
-                    inRange: true,
-                    x: normalizedX * 65536,
-                    y: normalizedY * 65536,
+                    x: UNSIGNED_OUT_OF_RANGE,
+                    y: UNSIGNED_OUT_OF_RANGE,
                 };
             }
+            return {
+                inRange: true,
+                x: normalizedX * UNSIGNED_RANGE,
+                y: normalizedY * UNSIGNED_RANGE,
+            };
         };
-        // Signed.
         this.normalizeAndQuantizeSigned = (x, y) => {
             const normalizedX = x / (0.5 * videoElement.clientWidth);
             const normalizedY = y / (0.5 * videoElement.clientHeight);
             return {
-                x: normalizedX * 32767,
-                y: normalizedY * 32767,
+                x: normalizedX * SIGNED_RANGE,
+                y: normalizedY * SIGNED_RANGE,
             };
         };
     }
@@ -4695,7 +4674,7 @@ class InputService extends SubService {
             y: (clientY - offsetByY - this.videoBoundingRect.top) * scaleY,
         };
     }
-    getMousePositionWithOffset({ offsetX, offsetY, }) {
+    getMousePositionWithOffset({ offsetX, offsetY }) {
         const { offsetByX, offsetByY, scaleX, scaleY } = this.offsetParams;
         return {
             x: (offsetX - offsetByX) * scaleX,
@@ -4703,8 +4682,6 @@ class InputService extends SubService {
         };
     }
     registerTouchEvents(htmlVideoElement) {
-        // We need to assign a unique identifier to each finger.
-        // We do this by mapping each Touch object to the identifier.
         const rememberTouch = (touch) => {
             const finger = this.fingers.pop();
             if (finger === undefined) {
@@ -4715,39 +4692,41 @@ class InputService extends SubService {
         };
         const forgetTouch = (touch) => {
             const finger = this.fingerIds.get(touch.identifier);
-            if (finger) {
+            if (finger !== undefined) {
                 this.fingers.push(finger);
+                // Re-sort descending so the lowest available id is popped next.
+                this.fingers.sort((a, b) => b - a);
             }
-            // Sort array back into descending order. This means if finger '1' were to lift after finger '0', we would ensure that 0 will be the first index to pop
-            this.fingers.sort((a, b) => b - a);
             this.fingerIds.delete(touch.identifier);
         };
         const emitTouchData = (type, touches) => {
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
             for (let t = 0; t < touches.length; t++) {
                 let byte = 2;
-                const numTouches = 1; // the number of touches to be sent this message
+                const numTouches = 1;
                 const touch = touches[t];
+                const finger = this.fingerIds.get(touch.identifier);
+                // Skip unknown identifiers (e.g., stale touch on a fast retap) — sending
+                // 0 here would alias finger '0' and corrupt UE's touch state.
+                if (finger === undefined) {
+                    continue;
+                }
                 const { x, y } = this.getTouchPositionWithOffset(touch);
-                Logger.info(`F${this.fingerIds.get(touch.identifier)}=(${x}, ${y})`);
-                const normalizeCoordinates = this.normalizeAndQuantizeUnsigned(x, y);
+                Logger.info(`F${finger}=(${x}, ${y})`);
+                const coord = this.normalizeAndQuantizeUnsigned(x, y);
                 const data = new DataView(new ArrayBuffer(9));
                 data.setUint8(0, type);
                 data.setUint8(1, numTouches);
-                data.setUint16(byte, normalizeCoordinates.x, true);
+                data.setUint16(byte, coord.x, true);
                 byte += 2;
-                data.setUint16(byte, normalizeCoordinates.y, true);
+                data.setUint16(byte, coord.y, true);
                 byte += 2;
-                const finger = this.fingerIds.get(touch.identifier);
-                if (finger) {
-                    data.setUint8(byte, finger);
-                }
+                data.setUint8(byte, finger);
                 byte += 1;
-                // force is between 0.0 and 1.0, so quantize into byte.
-                // iOs bug: Forced to be always 0.5 on all devices as we do not use forced touch any way;/
+                // iOS bug: force is locked to 0.5 since forced touch is unused.
                 data.setUint8(byte, this.maxByteValue * 0.5);
                 byte += 1;
-                data.setUint8(byte, normalizeCoordinates.inRange ? 1 : 0);
+                data.setUint8(byte, coord.inRange ? 1 : 0);
                 byte += 1;
                 this.sendInputData(data.buffer);
             }
@@ -4757,7 +4736,6 @@ class InputService extends SubService {
             .subscribe((e) => {
             this.focusWindow();
             const touches = e.changedTouches;
-            // Assign a unique identifier to each touch.
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
             for (let t = 0; t < touches.length; t++) {
                 rememberTouch(touches[t]);
@@ -4772,7 +4750,6 @@ class InputService extends SubService {
             const touches = e.changedTouches;
             Logger.info('touch end');
             emitTouchData(MessageType.TouchEnd, touches);
-            // Re-cycle unique identifiers previously assigned to each touch.
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
             for (let t = 0; t < touches.length; t++) {
                 forgetTouch(touches[t]);
@@ -4790,45 +4767,41 @@ class InputService extends SubService {
         window.focus();
     }
     emitMouseMove(x, y, deltaX, deltaY) {
-        const normalizeCoordinates = this.normalizeAndQuantizeUnsigned(x, y);
-        this.lastNormalizedCoordinates = normalizeCoordinates;
+        const coord = this.normalizeAndQuantizeUnsigned(x, y);
         const delta = this.normalizeAndQuantizeSigned(deltaX, deltaY);
         const data = new DataView(new ArrayBuffer(9));
         data.setUint8(0, MessageType.MouseMove);
-        data.setUint16(1, normalizeCoordinates.x, true);
-        data.setUint16(3, normalizeCoordinates.y, true);
+        data.setUint16(1, coord.x, true);
+        data.setUint16(3, coord.y, true);
         data.setInt16(5, delta.x, true);
         data.setInt16(7, delta.y, true);
         this.sendInputData(data.buffer);
     }
     emitMouseDown(button, x, y) {
-        const normalizeCoordinates = this.normalizeAndQuantizeUnsigned(x, y);
-        this.lastNormalizedCoordinates = normalizeCoordinates;
+        const coord = this.normalizeAndQuantizeUnsigned(x, y);
         const data = new DataView(new ArrayBuffer(6));
         data.setUint8(0, MessageType.MouseDown);
         data.setUint8(1, button);
-        data.setUint16(2, normalizeCoordinates.x, true);
-        data.setUint16(4, normalizeCoordinates.y, true);
+        data.setUint16(2, coord.x, true);
+        data.setUint16(4, coord.y, true);
         this.sendInputData(data.buffer);
     }
     emitMouseUp(button, x, y) {
-        const normalizeCoordinates = this.normalizeAndQuantizeUnsigned(x, y);
-        this.lastNormalizedCoordinates = normalizeCoordinates;
+        const coord = this.normalizeAndQuantizeUnsigned(x, y);
         const data = new DataView(new ArrayBuffer(6));
         data.setUint8(0, MessageType.MouseUp);
         data.setUint8(1, button);
-        data.setUint16(2, normalizeCoordinates.x, true);
-        data.setUint16(4, normalizeCoordinates.y, true);
+        data.setUint16(2, coord.x, true);
+        data.setUint16(4, coord.y, true);
         this.sendInputData(data.buffer);
     }
     emitMouseWheel(delta, x, y) {
-        const normalizeCoordinates = this.normalizeAndQuantizeUnsigned(x, y);
-        this.lastNormalizedCoordinates = normalizeCoordinates;
+        const coord = this.normalizeAndQuantizeUnsigned(x, y);
         const data = new DataView(new ArrayBuffer(7));
         data.setUint8(0, MessageType.MouseWheel);
         data.setInt16(1, delta, true);
-        data.setUint16(3, normalizeCoordinates.x, true);
-        data.setUint16(5, normalizeCoordinates.y, true);
+        data.setUint16(3, coord.x, true);
+        data.setUint16(5, coord.y, true);
         this.sendInputData(data.buffer);
     }
     releaseMouseButtons(buttons, x, y) {
@@ -4848,7 +4821,6 @@ class InputService extends SubService {
             this.emitMouseUp(MouseButton.FifthButton, x, y);
         }
     }
-    // If the user has any mouse buttons pressed, then press them again.
     pressMouseButtons(buttons, x, y) {
         if (buttons & MouseButtonsMask.PrimaryButton) {
             this.emitMouseDown(MouseButton.MainButton, x, y);
@@ -4892,7 +4864,7 @@ class InputService extends SubService {
         fromEvent(htmlVideoElement, 'wheel')
             .pipe(takeUntil$1(this.deactivatedVideoTrigger$))
             .subscribe((e) => {
-            this.emitMouseWheel(e.deltaY * -120, e.offsetX, e.offsetY);
+            this.emitMouseWheel(e.deltaY * WHEEL_DELTA_SCALE, e.offsetX, e.offsetY);
             e.preventDefault();
         });
     }
@@ -4909,7 +4881,6 @@ class InputService extends SubService {
         fromEvent(htmlVideoElement, 'mouseleave')
             .pipe(takeUntil$1(this.deactivatedVideoTrigger$))
             .subscribe((e) => {
-            this.lastNormalizedCoordinates = null;
             const data = new DataView(new ArrayBuffer(1));
             data.setUint8(0, MessageType.MouseLeave);
             this.sendInputData(data.buffer);
@@ -4918,8 +4889,8 @@ class InputService extends SubService {
     }
     // Browser keys do not have a charCode so we only need to test keyCode.
     isKeyCodeBrowserKey(keyCode) {
-        // Function keys or tab key.
-        return (keyCode >= 112 && keyCode <= 123) || keyCode === 9;
+        return ((keyCode >= FUNCTION_KEY_MIN && keyCode <= FUNCTION_KEY_MAX) ||
+            keyCode === TAB_KEY_CODE);
     }
     getKeyCode(e) {
         if (e.keyCode === SpecialKeyCodes.Shift && e.code === 'ShiftRight')
@@ -4932,9 +4903,7 @@ class InputService extends SubService {
             return e.keyCode;
     }
     registerKeyboardEvents(availableKeys) {
-        const availableKeyNames = Object.entries(availableKeys).map(([, value]) => {
-            return InvertedKeyMap[value];
-        });
+        const availableKeyNames = availableKeys.map((value) => InvertedKeyMap[value]);
         const keyBlock = (event) => {
             const code = event.code;
             const isInputFieldFocused = event.target?.localName === 'input';
@@ -4949,7 +4918,6 @@ class InputService extends SubService {
     }
     startListenKeys(_filter) {
         const filter = _filter ?? (() => false);
-        // Use RxJS fromEvent with takeUntil to properly clean up subscriptions
         fromEvent(document, 'keydown')
             .pipe(takeUntil$1(this.deactivatedVideoTrigger$))
             .subscribe((e) => {
@@ -4967,8 +4935,8 @@ class InputService extends SubService {
                 this.getKeyCode(e),
                 Number(e.repeat),
             ]).buffer);
-            // Backspace is not considered a keypress in JavaScript, but we need it
-            // to be so characters may be deleted in a UE4 text entry field.
+            // Backspace isn't a keypress in JS, but UE4 text-entry fields need it
+            // to delete characters.
             if (e.keyCode === SpecialKeyCodes.BackSpace) {
                 const data = new DataView(new ArrayBuffer(3));
                 data.setUint8(0, MessageType.KeyPress);