Upload preprocess_manual.js

preprocess_manual.js

@@ -573,9 +573,11 @@ export function preprocessManual(vrmPath, gsPath, scene, camera, renderer, stage
           let animationId = null;
           function animateControls() {
             animationId = requestAnimationFrame(animateControls);
+            updateCameraFromKeys();  // ⭐ この行を追加
             cameraControls.controls.update();
             renderer.render(scene, camera);
           }
+
           animateControls();
           
           // Cleanup function to stop animation
@@ -586,6 +588,213 @@ export function preprocessManual(vrmPath, gsPath, scene, camera, renderer, stage
             }
           };
           
+////////////////handle key 1213 13:30
+
+      // ========================================
+      // Keyboard Controls for Camera Movement
+      // ========================================
+      let activeKeys = [];
+
+      // Key event listeners
+      window.addEventListener("keydown", (e) => {
+        if (!activeKeys.includes(e.code)) {
+          activeKeys.push(e.code);
+        }
+      });
+
+      window.addEventListener("keyup", (e) => {
+        activeKeys = activeKeys.filter((k) => k !== e.code);
+      });
+
+      window.addEventListener("blur", () => {
+        activeKeys = [];
+      });
+
+      // Camera manipulation function (called in animation loop)
+      function updateCameraFromKeys() {
+        if (activeKeys.length === 0) return;
+        
+        // Get current camera matrix (inverse of view matrix)
+        let inv = invert4(camera.matrixWorld.elements);
+        if (!inv) return;
+        
+        const shiftKey = activeKeys.includes("ShiftLeft") || activeKeys.includes("ShiftRight");
+        
+        // Movement (arrow keys)
+        if (activeKeys.includes("ArrowUp")) {
+          if (shiftKey) {
+            // Move up (Y axis)
+            inv = translate4(inv, 0, -0.03, 0);
+          } else {
+            // Move forward (Z axis)
+            inv = translate4(inv, 0, 0, 0.1);
+          }
+        }
+        if (activeKeys.includes("ArrowDown")) {
+          if (shiftKey) {
+            // Move down (Y axis)
+            inv = translate4(inv, 0, 0.03, 0);
+          } else {
+            // Move backward (Z axis)
+            inv = translate4(inv, 0, 0, -0.1);
+          }
+        }
+        if (activeKeys.includes("ArrowLeft")) {
+          // Strafe left (X axis)
+          inv = translate4(inv, -0.03, 0, 0);
+        }
+        if (activeKeys.includes("ArrowRight")) {
+          // Strafe right (X axis)
+          inv = translate4(inv, 0.03, 0, 0);
+        }
+        
+        // Camera angle (WASD keys)
+        if (activeKeys.includes("KeyA")) {
+          // Turn left (Y axis rotation)
+          inv = rotate4(inv, -0.01, 0, 1, 0);
+        }
+        if (activeKeys.includes("KeyD")) {
+          // Turn right (Y axis rotation)
+          inv = rotate4(inv, 0.01, 0, 1, 0);
+        }
+        if (activeKeys.includes("KeyW")) {
+          // Tilt up (X axis rotation)
+          inv = rotate4(inv, 0.005, 1, 0, 0);
+        }
+        if (activeKeys.includes("KeyS")) {
+          // Tilt down (X axis rotation)
+          inv = rotate4(inv, -0.005, 1, 0, 0);
+        }
+        if (activeKeys.includes("KeyQ")) {
+          // Roll counterclockwise (Z axis rotation)
+          inv = rotate4(inv, 0.01, 0, 0, 1);
+        }
+        if (activeKeys.includes("KeyE")) {
+          // Roll clockwise (Z axis rotation)
+          inv = rotate4(inv, -0.01, 0, 0, 1);
+        }
+        
+        // Orbit (I/K and J/L keys)
+        if (activeKeys.includes("KeyI") || activeKeys.includes("KeyK") || 
+            activeKeys.includes("KeyJ") || activeKeys.includes("KeyL")) {
+          let d = 4;
+          inv = translate4(inv, 0, 0, d);
+          inv = rotate4(
+            inv,
+            activeKeys.includes("KeyJ") ? -0.05 : activeKeys.includes("KeyL") ? 0.05 : 0,
+            0, 1, 0
+          );
+          inv = rotate4(
+            inv,
+            activeKeys.includes("KeyI") ? 0.05 : activeKeys.includes("KeyK") ? -0.05 : 0,
+            1, 0, 0
+          );
+          inv = translate4(inv, 0, 0, -d);
+        }
+        
+        // Apply the transformation back to camera
+        const newMatrix = invert4(inv);
+        if (newMatrix) {
+          camera.matrix.fromArray(newMatrix);
+          camera.matrix.decompose(camera.position, camera.quaternion, camera.scale);
+          camera.updateMatrixWorld(true);
+          
+          // Disable OrbitControls temporarily when using keyboard
+          if (cameraControls && cameraControls.controls) {
+            cameraControls.controls.enabled = false;
+            // Re-enable after a short delay
+            setTimeout(() => {
+              if (cameraControls && cameraControls.controls) {
+                cameraControls.controls.enabled = true;
+              }
+            }, 100);
+          }
+        }
+      }
+
+      // Helper functions for matrix operations (if not already present)
+      function invert4(a) {
+        let b00 = a[0] * a[5] - a[1] * a[4];
+        let b01 = a[0] * a[6] - a[2] * a[4];
+        let b02 = a[0] * a[7] - a[3] * a[4];
+        let b03 = a[1] * a[6] - a[2] * a[5];
+        let b04 = a[1] * a[7] - a[3] * a[5];
+        let b05 = a[2] * a[7] - a[3] * a[6];
+        let b06 = a[8] * a[13] - a[9] * a[12];
+        let b07 = a[8] * a[14] - a[10] * a[12];
+        let b08 = a[8] * a[15] - a[11] * a[12];
+        let b09 = a[9] * a[14] - a[10] * a[13];
+        let b10 = a[9] * a[15] - a[11] * a[13];
+        let b11 = a[10] * a[15] - a[11] * a[14];
+        let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+        if (!det) return null;
+        return [
+          (a[5] * b11 - a[6] * b10 + a[7] * b09) / det,
+          (a[2] * b10 - a[1] * b11 - a[3] * b09) / det,
+          (a[13] * b05 - a[14] * b04 + a[15] * b03) / det,
+          (a[10] * b04 - a[9] * b05 - a[11] * b03) / det,
+          (a[6] * b08 - a[4] * b11 - a[7] * b07) / det,
+          (a[0] * b11 - a[2] * b08 + a[3] * b07) / det,
+          (a[14] * b02 - a[12] * b05 - a[15] * b01) / det,
+          (a[8] * b05 - a[10] * b02 + a[11] * b01) / det,
+          (a[4] * b10 - a[5] * b08 + a[7] * b06) / det,
+          (a[1] * b08 - a[0] * b10 - a[3] * b06) / det,
+          (a[12] * b04 - a[13] * b02 + a[15] * b00) / det,
+          (a[9] * b02 - a[8] * b04 - a[11] * b00) / det,
+          (a[5] * b07 - a[4] * b09 - a[6] * b06) / det,
+          (a[0] * b09 - a[1] * b07 + a[2] * b06) / det,
+          (a[13] * b01 - a[12] * b03 - a[14] * b00) / det,
+          (a[8] * b03 - a[9] * b01 + a[10] * b00) / det,
+        ];
+      }
+
+      function rotate4(a, rad, x, y, z) {
+        let len = Math.hypot(x, y, z);
+        x /= len;
+        y /= len;
+        z /= len;
+        let s = Math.sin(rad);
+        let c = Math.cos(rad);
+        let t = 1 - c;
+        let b00 = x * x * t + c;
+        let b01 = y * x * t + z * s;
+        let b02 = z * x * t - y * s;
+        let b10 = x * y * t - z * s;
+        let b11 = y * y * t + c;
+        let b12 = z * y * t + x * s;
+        let b20 = x * z * t + y * s;
+        let b21 = y * z * t - x * s;
+        let b22 = z * z * t + c;
+        return [
+          a[0] * b00 + a[4] * b01 + a[8] * b02,
+          a[1] * b00 + a[5] * b01 + a[9] * b02,
+          a[2] * b00 + a[6] * b01 + a[10] * b02,
+          a[3] * b00 + a[7] * b01 + a[11] * b02,
+          a[0] * b10 + a[4] * b11 + a[8] * b12,
+          a[1] * b10 + a[5] * b11 + a[9] * b12,
+          a[2] * b10 + a[6] * b11 + a[10] * b12,
+          a[3] * b10 + a[7] * b11 + a[11] * b12,
+          a[0] * b20 + a[4] * b21 + a[8] * b22,
+          a[1] * b20 + a[5] * b21 + a[9] * b22,
+          a[2] * b20 + a[6] * b21 + a[10] * b22,
+          a[3] * b20 + a[7] * b21 + a[11] * b22,
+          ...a.slice(12, 16),
+        ];
+      }
+
+      function translate4(a, x, y, z) {
+        return [
+          ...a.slice(0, 12),
+          a[0] * x + a[4] * y + a[8] * z + a[12],
+          a[1] * x + a[5] * y + a[9] * z + a[13],
+          a[2] * x + a[6] * y + a[10] * z + a[14],
+          a[3] * x + a[7] * y + a[11] * z + a[15],
+        ];
+      }
+
+
+//////////////
+
           // ========================================
           // Step 0: PLY Position Adjustment
           // ========================================
@@ -677,9 +886,11 @@ export function preprocessManual(vrmPath, gsPath, scene, camera, renderer, stage
               // ★★★ RESTART ANIMATION FOR BOX ADJUSTMENT ★★★
               function animateBoxAdjustment() {
                 animationId = requestAnimationFrame(animateBoxAdjustment);
+                updateCameraFromKeys();  // ⭐ この行を追加
                 cameraControls.controls.update();
                 renderer.render(scene, camera);
               }
+
               animateBoxAdjustment();
               
               let boxSize = { x: 2, y: 2, z: 2 };