Update deplacement_dans_env/ctrl_camera_pr_env.js

deplacement_dans_env/ctrl_camera_pr_env.js

@@ -1,8 +1,11 @@
 // ctrl_camera_pr_env.js
 // ============================================================================
-// ORBIT CAMERA + INPUTS (PlayCanvas) — version bbox + sans maxZoom
-// - Contraintes : minY (altitude min caméra), Bounding Box (X/Y/Z min/max)
-// - Zoom : seul un minimum est imposé (plus de maxZoom)
+// ORBIT CAMERA + INPUTS (PlayCanvas) — version bbox "rotation-libre"
+// - Zoom : uniquement un minimum (pas de maxZoom)
+// - Bounding Box : on contraint UNIQUEMENT la position caméra
+//   -> si la position sort, on la clampe puis on décale le pivot
+//      pour conserver l'orientation ET la distance (orbite fluide).
+// - minY : altitude mini de la caméra (appliquée comme une "box" horizontale)
 // ============================================================================
 
 var OrbitCamera = pc.createScript('orbitCamera');
@@ -61,20 +64,16 @@ OrbitCamera.prototype.focus = function (focusEntity) {
     this._buildAabb(focusEntity);
     var halfExtents = this._modelsAabb.halfExtents;
     var radius = Math.max(halfExtents.x, Math.max(halfExtents.y, halfExtents.z));
-
-    // calcule distance initiale (pas de maxZoom à respecter)
+    // Distance initiale (pas de maxZoom)
     this.distance = (radius * 1.5) / Math.sin(0.5 * this.entity.camera.fov * pc.math.DEG_TO_RAD);
-
     this._removeInertia();
     this._pivotPoint.copy(this._modelsAabb.center);
-    this._clampPivotToBBox(this._pivotPoint);
 };
 
 OrbitCamera.distanceBetween = new pc.Vec3();
 
 OrbitCamera.prototype.resetAndLookAtPoint = function (resetPoint, lookAtPoint) {
     this.pivotPoint.copy(lookAtPoint);
-    this._clampPivotToBBox(this._pivotPoint);
 
     this.entity.setPosition(resetPoint);
     this.entity.lookAt(lookAtPoint);
@@ -107,7 +106,6 @@ OrbitCamera.prototype.resetToPosition = function (position, lookAtPoint) {
     this.entity.setPosition(position);
     this.entity.lookAt(lookAtPoint);
     this._pivotPoint.copy(lookAtPoint);
-    this._clampPivotToBBox(this._pivotPoint);
 
     var distanceVec = new pc.Vec3();
     distanceVec.sub2(position, lookAtPoint);
@@ -121,7 +119,7 @@ OrbitCamera.prototype.resetToPosition = function (position, lookAtPoint) {
     this._updatePosition();
 };
 
-// ==== Helper: calc cam Y if pivot became 'pivot' (used to enforce minY) ====
+// ==== Helper: cam Y si le pivot = 'pivot' (sert pour minY) ====
 OrbitCamera.prototype.worldCameraYForPivot = function(pivot) {
     var quat = new pc.Quat();
     quat.setFromEulerAngles(this._pitch, this._yaw, 0);
@@ -145,7 +143,6 @@ OrbitCamera.prototype.initialize = function () {
     this.entity.lookAt(this._modelsAabb.center);
     this._pivotPoint = new pc.Vec3();
     this._pivotPoint.copy(this._modelsAabb.center);
-    this._clampPivotToBBox(this._pivotPoint);
 
     var cameraQuat = this.entity.getRotation();
     this._yaw = this._calcYaw(cameraQuat);
@@ -165,7 +162,7 @@ OrbitCamera.prototype.initialize = function () {
     }
     this._targetDistance = this._distance;
 
-    // Listeners d’attributs (note: pas de distanceMax)
+    // Listeners d’attributs
     this.on('attr:distanceMin',   function () { this._distance = this._clampDistance(this._distance); });
     this.on('attr:pitchAngleMin', function () { this._pitch = this._clampPitchAngle(this._pitch); });
     this.on('attr:pitchAngleMax', function () { this._pitch = this._clampPitchAngle(this._pitch); });
@@ -179,10 +176,6 @@ OrbitCamera.prototype.initialize = function () {
         if (value) { this.focus(this.focusEntity || this.app.root); }
     });
 
-    // Clamp bbox dynamique
-    var bboxAttrs = ['Xmin','Xmax','Ymin','Ymax','Zmin','Zmax'];
-    bboxAttrs.forEach((a)=> this.on('attr:'+a, function(){ this._clampPivotToBBox(this._pivotPoint); this._updatePosition(); }));
-
     this.on('destroy', function () { window.removeEventListener('resize', onWindowResize, false); });
 };
 
@@ -195,24 +188,33 @@ OrbitCamera.prototype.update = function (dt) {
 };
 
 OrbitCamera.prototype._updatePosition = function () {
+    // 1) oriente la caméra
     this.entity.setLocalPosition(0, 0, 0);
     this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
 
-    var position = this.entity.getPosition();
-    position.copy(this.entity.forward);
-    position.mulScalar(-this._distance);
-    position.add(this.pivotPoint);
+    // 2) calcule la position théorique en fonction du pivot et de la distance
+    var forward = this.entity.forward.clone(); // direction de visée
+    var desired = this._pivotPoint.clone().add(forward.clone().mulScalar(-this._distance));
 
-    // 1) altitude mini
-    position.y = Math.max(position.y, this.minY);
+    // 3) applique minY (comme un plan horizontal)
+    if (desired.y < this.minY) {
+        desired.y = this.minY;
+    }
 
-    // 2) clamp BBox caméra
-    this._applyBoundingBox(position);
+    // 4) contraint UNIQUEMENT la position caméra à la bbox
+    var clamped = desired.clone();
+    var wasClamped = this._applyBoundingBox(clamped); // retourne true si clamp effectué
 
-    this.entity.setPosition(position);
+    // 5) positionne la caméra
+    this.entity.setPosition(clamped);
 
-    // 3) assure que le pivot reste dans la bbox
-    this._clampPivotToBBox(this._pivotPoint);
+    // 6) si clamp (bbox ou minY), on recalcule un pivot cohérent sur le même rayon
+    //    (préserve orientation + distance => rotation reste fluide au contact)
+    if (wasClamped || clamped.y !== desired.y) {
+        // forward pointe de la caméra vers la scène
+        // pos = pivot - forward * distance  =>  pivot = pos + forward * distance
+        this._pivotPoint.copy(clamped.clone().add(forward.mulScalar(this._distance)));
+    }
 };
 
 OrbitCamera.prototype._removeInertia = function () {
@@ -268,7 +270,6 @@ OrbitCamera.prototype._calcYaw = function (quat) {
 };
 
 OrbitCamera.prototype._clampDistance = function (distance) {
-    // Plus de distanceMax : uniquement un minimum
     return Math.max(distance, this.distanceMin);
 };
 
@@ -298,18 +299,22 @@ OrbitCamera.prototype._bboxEnabled = function () {
     return (this.Xmin < this.Xmax) && (this.Ymin < this.Ymax) && (this.Zmin < this.Zmax);
 };
 
+/**
+ * Contrainte position caméra à la bbox.
+ * @returns {boolean} true si un clamp a été appliqué
+ */
 OrbitCamera.prototype._applyBoundingBox = function (v3 /* camera position */) {
-    if (!this._bboxEnabled()) return;
-    v3.x = pc.math.clamp(v3.x, this.Xmin, this.Xmax);
-    v3.y = pc.math.clamp(v3.y, this.Ymin, this.Ymax);
-    v3.z = pc.math.clamp(v3.z, this.Zmin, this.Zmax);
-};
+    if (!this._bboxEnabled()) return false;
+
+    var clamped = false;
+    var nx = pc.math.clamp(v3.x, this.Xmin, this.Xmax);
+    var ny = pc.math.clamp(v3.y, this.Ymin, this.Ymax);
+    var nz = pc.math.clamp(v3.z, this.Zmin, this.Zmax);
 
-OrbitCamera.prototype._clampPivotToBBox = function (v3 /* pivot */) {
-    if (!this._bboxEnabled()) return;
-    v3.x = pc.math.clamp(v3.x, this.Xmin, this.Xmax);
-    v3.y = pc.math.clamp(v3.y, this.Ymin, this.Ymax);
-    v3.z = pc.math.clamp(v3.z, this.Zmin, this.Zmax);
+    if (nx !== v3.x || ny !== v3.y || nz !== v3.z) clamped = true;
+
+    v3.x = nx; v3.y = ny; v3.z = nz;
+    return clamped;
 };
 
 // ===================== Orbit Camera Input Mouse ========================
@@ -358,26 +363,24 @@ OrbitCameraInputMouse.prototype.pan = function (screenPoint) {
     var camera   = this.entity.camera;
     var distance = this.orbitCamera.distance;
 
-    camera.screenToWorld(screenPoint.x, this.lastPoint.y, distance, fromWorldPoint);
+    camera.screenToWorld(screenPoint.x, screenPoint.y, distance, fromWorldPoint);
     camera.screenToWorld(this.lastPoint.x, this.lastPoint.y, distance, toWorldPoint);
 
     worldDiff.sub2(toWorldPoint, fromWorldPoint);
 
-    // Enforce minY + bbox via pivot
+    // Enforce minY via test sur la position caméra résultante
     var proposedPivot = this.orbitCamera.pivotPoint.clone().add(worldDiff);
-    var minY = this.orbitCamera.minY;
-    var resultingY = this.orbitCamera.worldCameraYForPivot(proposedPivot);
 
-    if (resultingY >= minY - 1e-4) {
-        this.orbitCamera._clampPivotToBBox(proposedPivot);
+    // calcule Y caméra si on acceptait ce pivot (sans bbox ici)
+    var camY = this.orbitCamera.worldCameraYForPivot(proposedPivot);
+    if (camY >= this.orbitCamera.minY - 1e-4) {
         this.orbitCamera.pivotPoint.copy(proposedPivot);
     } else {
-        // Horizontal-only si nécessaire
+        // Essai horizontal-only
         worldDiff.y = 0;
         proposedPivot = this.orbitCamera.pivotPoint.clone().add(worldDiff);
-        resultingY = this.orbitCamera.worldCameraYForPivot(proposedPivot);
-        if (resultingY >= minY - 1e-4) {
-            this.orbitCamera._clampPivotToBBox(proposedPivot);
+        camY = this.orbitCamera.worldCameraYForPivot(proposedPivot);
+        if (camY >= this.orbitCamera.minY - 1e-4) {
             this.orbitCamera.pivotPoint.copy(proposedPivot);
         }
     }
@@ -525,14 +528,12 @@ OrbitCameraInputTouch.prototype.pan = function (midPoint) {
     var resultingY = this.orbitCamera.worldCameraYForPivot(proposedPivot);
 
     if (resultingY >= minY - 1e-4) {
-        this.orbitCamera._clampPivotToBBox(proposedPivot);
         this.orbitCamera.pivotPoint.copy(proposedPivot);
     } else {
         worldDiff.y = 0;
         proposedPivot = this.orbitCamera.pivotPoint.clone().add(worldDiff);
         resultingY = this.orbitCamera.worldCameraYForPivot(proposedPivot);
         if (resultingY >= minY - 1e-4) {
-            this.orbitCamera._clampPivotToBBox(proposedPivot);
             this.orbitCamera.pivotPoint.copy(proposedPivot);
         }
     }
@@ -595,7 +596,7 @@ OrbitCameraInputTouch.prototype.onTouchMove = function (event) {
 
 // =================== Orbit Camera Input Keyboard ========================
 // Flèches : déplacement avant/arrière & droite/gauche (repère caméra, 3D)
-// Ctrl+flèches : orbiter autour du pivot
+// Ctrl+flèches : orbiter autour du pivot (avec test minY)
 // Maj+flèches : rotation libre sur place (pas de limites yaw/pitch)
 var OrbitCameraInputKeyboard = pc.createScript('orbitCameraInputKeyboard');
 
@@ -677,7 +678,6 @@ OrbitCameraInputKeyboard.prototype.update = function (dt) {
         var q = new pc.Quat().setFromEulerAngles(this.orbitCamera._pitch, this.orbitCamera._yaw, 0);
         var forward = new pc.Vec3(); q.transformVector(pc.Vec3.FORWARD, forward);
         var newPivot = camPos.clone().add(forward.clone().mulScalar(dist));
-        this.orbitCamera._clampPivotToBBox(newPivot);
         this.orbitCamera._pivotPoint.copy(newPivot);
 
         this.orbitCamera._removeInertia();
@@ -712,8 +712,6 @@ OrbitCameraInputKeyboard.prototype.update = function (dt) {
         if (currCamY + delta.y < minY) {
             delta.y = minY - currCamY;
         }
-        var newPivot = this.orbitCamera._pivotPoint.clone().add(delta);
-        this.orbitCamera._clampPivotToBBox(newPivot);
-        this.orbitCamera._pivotPoint.copy(newPivot);
+        this.orbitCamera._pivotPoint.add(delta);
     }
 };