Update viewer_ar_ios.js

viewer_ar_ios.js

@@ -1,12 +1,12 @@
-/* viewer_ar_ios.js — AR PlayCanvas + GLB/USDZ via config.json (+ "sol" + mode mur stable)
+/* viewer_ar_ios.js — AR PlayCanvas + GLB/USDZ via config.json (+ "sol" + mode mur : Z = normale, Y = haut)
    - config.json : { "glb_url": "...", "usdz_url": "...", "sol": true|false }
    - sol = true  → plans horizontaux (sol) + rotation autour de l’axe local Y (haut)
    - sol = false → plans verticaux (mur) :
-       * Y local = normale du mur
-       * Z local = direction plafond (Up monde) projetée dans le plan du mur
-       * rotation utilisateur = autour de Y local (normale)
+       * Z local = normale du mur (perpendiculaire au plan)
+       * Y local = direction plafond (Up monde) projetée dans le plan
+       * rotation utilisateur = autour de Z local (normale)
        * PENDANT une translation : orientation verrouillée (pas de twist parasite)
-       * À la fin d’une translation : on recalcule la base par rapport AU NOUVEAU MUR
+       * À la fin d’une translation : réalignement base sur le NOUVEAU mur (Z=normale, Y→plafond)
    - iOS : AR Quick Look (USDZ)
    - Android/Desktop : WebXR AR + bouton "Lancer l’AR" + slider de rotation
 */
@@ -305,8 +305,7 @@
         } else {
           message(
             "Modèle chargé. Appuyez sur « Lancer l’AR ». Sur iOS (Quick Look), l’objet ne peut pas être " +
-            "automatiquement aligné au mur : placez-le et orientez-le manuellement " +
-            "contre le mur (Z vers le plafond)."
+            "aligné automatiquement au mur : placez-le et orientez-le manuellement (Y vers le plafond)."
           );
         }
       } else {
@@ -397,18 +396,17 @@
       var d = v.dot(n);
       return new pc.Vec3(v.x - d*n.x, v.y - d*n.y, v.z - d*n.z);
     }
-    function normalizeOr(v, fallback) {
-      var len = v.length();
-      if (len > 1e-6) { v.scale(1/len); return v; }
-      return fallback.clone ? fallback.clone() : new pc.Vec3(fallback.x, fallback.y, fallback.z);
-    }
-    function buildWallBasisFromNormal(N) {
-      var Y = N.clone().normalize();                 // Y = normale du mur
-      var Z = projOnPlane(UP, Y);                    // Z = Up projeté (vers plafond)
-      if (Z.lengthSq() < 1e-8) Z = projOnPlane(new pc.Vec3(0,0,1), Y);
-      Z.normalize();
-      var X = new pc.Vec3(); X.cross(Z, Y).normalize(); // X = Z × Y
-      Z.cross(Y, X).normalize();                         // Re-orthonormalise
+    function buildWallBasisFromNormalZ(Nz) {
+      // Z local = normale du mur
+      var Z = Nz.clone().normalize();
+      // Y local = Up projété dans le plan (toujours "vers le plafond" le long du mur)
+      var Y = projOnPlane(UP, Z);
+      if (Y.lengthSq() < 1e-8) Y = projOnPlane(new pc.Vec3(0,1,0), Z);
+      Y.normalize();
+      // X = Y × Z  (garantit base orthonormée et droite, avec X×Y = Z)
+      var X = new pc.Vec3(); X.cross(Y, Z).normalize();
+      // Re-orthonormalise Y = Z × X pour éliminer la dérive
+      Y.cross(Z, X).normalize();
       return { X: X, Y: Y, Z: Z };
     }
     function quatFromBasis(X, Y, Z) {
@@ -447,19 +445,19 @@
       q.normalize();
       return q;
     }
-    function computeWallBaseFromRot(rot) {
-      // Y monde = rot * (0,1,0) = normale du mur
-      var N = new pc.Vec3();
-      rot.transformVector(new pc.Vec3(0, 1, 0), N);
-      N.normalize();
-      var basis = buildWallBasisFromNormal(N);
-      return quatFromBasis(basis.X, basis.Y, basis.Z); // Y=normale, Z=plafond
+    function computeWallBaseFromRot_ZNormal(rot) {
+      // WebXR/PlayCanvas : la normale du plan est l’axe Z de la pose
+      var Nz = new pc.Vec3();
+      rot.transformVector(new pc.Vec3(0, 0, 1), Nz); // Z monde de la pose
+      Nz.normalize();
+      var basis = buildWallBasisFromNormalZ(Nz);      // Z=normale, Y=Up projeté
+      return quatFromBasis(basis.X, basis.Y, basis.Z);
     }
 
     // Mode mur / sol
     var wallMode = !PLACE_ON_FLOOR;
-    var wallBaseRot = new pc.Quat(); // base (mur) : Y=normale, Z=plafond
-    var wallAngleDeg = 0;            // yaw utilisateur autour de Y local
+    var wallBaseRot = new pc.Quat(); // base (mur) : Z=normale, Y=up-projeté
+    var wallAngleDeg = 0;            // rotation utilisateur autour de Z local (normale)
 
     // Ombre blob (sol uniquement)
     var blob = null;
@@ -516,7 +514,7 @@
       return e;
     }
 
-    // Rotation via slider (sol: Euler Y, mur: twist autour de Y local)
+    // Rotation via slider (sol: Euler Y, mur: twist autour de Z local)
     var baseEulerX = 0, baseEulerZ = 0;
     var rotationYDeg = 0;
     function clamp360(d) { return Math.max(0, Math.min(360, d)); }
@@ -536,11 +534,12 @@
         rotationYDeg = y;
         modelRoot.setEulerAngles(baseEulerX, y, baseEulerZ);
       } else {
+        // mur : rotation autour de Z local
         wallAngleDeg = y;
         var qLocal = new pc.Quat();
-        qLocal.setFromAxisAngle(pc.Vec3.UP, y); // rotation autour de Y local (avant base)
+        qLocal.setFromAxisAngle(new pc.Vec3(0, 0, 1), y); // rotation locale autour de Z
         var qFinal = new pc.Quat();
-        qFinal.mul2(wallBaseRot, qLocal);       // base mur (Y=normale, Z=up projeté) puis yaw utilisateur
+        qFinal.mul2(wallBaseRot, qLocal);                 // base (Z=normale, Y=up projeté) puis twist utilisateur
         modelRoot.setRotation(qFinal);
       }
       updateKnobFromY(y);
@@ -583,17 +582,19 @@
 
     if (!app.xr.supported) { message("WebXR n’est pas supporté sur cet appareil."); return; }
 
-    // ----- Détection orientation des plans -----
-    var TMP_IN = new pc.Vec3(0, 1, 0), TMP_OUT = new pc.Vec3();
+    // ----- Détection orientation des plans (utilise Z comme normale) -----
+    var TMP_Z = new pc.Vec3(0, 0, 1), TMP_OUT = new pc.Vec3();
 
     function isHorizontalUpFacing(rot, minDot) {
+      // sol : normale (Z) ≈ +Y
       minDot = (typeof minDot === "number") ? minDot : 0.75;
-      rot.transformVector(TMP_IN, TMP_OUT);
+      rot.transformVector(TMP_Z, TMP_OUT);
       return TMP_OUT.y >= minDot;
     }
     function isVerticalFacing(rot, maxAbsY) {
+      // mur : normale (Z) quasi horizontale → |Z.y| petit
       maxAbsY = (typeof maxAbsY === "number") ? maxAbsY : 0.35;
-      rot.transformVector(TMP_IN, TMP_OUT);
+      rot.transformVector(TMP_Z, TMP_OUT);
       return Math.abs(TMP_OUT.y) <= maxAbsY;
     }
     function planeMatchesMode(rot) {
@@ -692,16 +693,16 @@
                 applyRotationY(y0);
               } else {
                 // --- MODE MUR (première pose) ---
-                wallBaseRot.copy(computeWallBaseFromRot(rot)); // Y=normale, Z=plafond
+                wallBaseRot.copy(computeWallBaseFromRot_ZNormal(rot)); // Z=normale, Y=up-projeté
                 modelRoot.setRotation(wallBaseRot);
-                applyRotationY(0); // yaw initial = 0
+                applyRotationY(0); // angle initial = 0 (autour de Z)
               }
 
               placedOnce = true;
               rotInput.disabled = false;
               message(
                 wallMode
-                  ? "Objet placé contre le mur (Y=normale, Z→plafond). Glissez pour déplacer, tournez avec le slider →"
+                  ? "Objet placé contre le mur (Z=normale, Y→plafond). Glissez pour déplacer, tournez avec le slider →"
                   : "Objet placé. Glissez pour déplacer, tournez-le avec le slider →"
               );
             }
@@ -711,6 +712,10 @@
     });
 
     // Drag XR continu (déplacements suivants, sans rotation parasite)
+    var isDragging = false;
+    var dragLockedRot = new pc.Quat();
+    var lastHitRot = new pc.Quat();
+
     app.xr.input.on("add", function (inputSource) {
       inputSource.on("selectstart", function () {
         if (uiInteracting) return;
@@ -729,29 +734,23 @@
               if (!isDragging) return;
               if (!planeMatchesMode(rot)) return;
 
-              // Mémorise la dernière orientation de plan rencontrée
-              lastHitRot.copy(rot);
-
-              // Déplace uniquement
-              modelRoot.setPosition(pos);
+              lastHitRot.copy(rot);        // garde trace du dernier mur rencontré
+              modelRoot.setPosition(pos);  // translate uniquement
 
               if (!wallMode) {
                 updateBlobPositionUnder(pos, rot);
               } else {
-                // En mode mur : PAS de rotation pendant le drag
-                modelRoot.setRotation(dragLockedRot);
+                modelRoot.setRotation(dragLockedRot); // aucune rotation pendant le drag
               }
             });
 
-            // Fin du drag : snap propre au NOUVEAU mur (si on est en mode mur)
+            // Fin du drag : snap orientation sur le NOUVEAU mur, en conservant l'angle utilisateur
             transientSource.once("remove", function () {
               isDragging = false;
               if (wallMode) {
-                // Recalcule la base avec le dernier mur touché
-                wallBaseRot.copy(computeWallBaseFromRot(lastHitRot));
-                // Ré-applique le yaw utilisateur autour de Y local (normale du NOUVEAU mur)
+                wallBaseRot.copy(computeWallBaseFromRot_ZNormal(lastHitRot));
                 var qLocal = new pc.Quat();
-                qLocal.setFromAxisAngle(pc.Vec3.UP, wallAngleDeg);
+                qLocal.setFromAxisAngle(new pc.Vec3(0, 0, 1), wallAngleDeg); // rotation autour de Z local
                 var qFinal = new pc.Quat();
                 qFinal.mul2(wallBaseRot, qLocal);
                 modelRoot.setRotation(qFinal);
@@ -795,10 +794,7 @@
       }
     });
     app.mouse.on("mouseup", function () {
-      if (isDragging) {
-        // En desktop on n'a pas lastHitRot : on garde l'orientation verrouillée
-        // (optionnel : on pourrait lancer un hit-test unique ici pour "snap", selon l'intégration)
-      }
+      // (optionnel) faire un snap sur desktop si tu déclenches un hit-test ici.
       isDragging = false;
       rotateMode = false;
     });
@@ -815,7 +811,7 @@
     app.xr.on("start", function () {
       if (startBtn) startBtn.style.display = "none";
       message(wallMode
-        ? "Session AR démarrée. Visez un mur (Y=normale, Z du modèle sera vers le plafond)…"
+        ? "Session AR démarrée. Visez un mur (Z=normale, Y du modèle vers le plafond)…"
         : "Session AR démarrée. Visez le sol pour détecter un plan…");
       reticle.enabled = true;
     });