Update hexagonal projection

Author: Léna Voinchet

js/scene/SceneManager.js

@@ -713,31 +713,39 @@ class SceneManager{
                     );
 
                     // Purple area
-                    coveredPointsAbove = [];
-                    if (intersectionPointsAbove.length > 2) {
-                        const tempProjectedToFloor = [];
-                        intersectionPointsAbove.forEach(originalPointOnAbovePlane => {
-                            const pointOnAbovePlane = originalPointOnAbovePlane.clone(); // Point on the Above Plane
-                            const pointProjectedToFloor = originalPointOnAbovePlane.clone();
-                            pointProjectedToFloor.y -= this.heightDetected; // Point projected on the Floor Plane
+                    const subjectPolygonProjected = [];
+
+                    intersectionPointsAbove.forEach(originalPoint => {
+                        // We only keep the points which are in the frustum at their real height
+                        if (pointInFrustum(originalPoint, frustumPlanesWorld)) {
+                            const projectedPoint = originalPoint.clone();
+                            projectedPoint.y = this.sceneElevation; // Projected on the floor
 
-                            if (pointInFrustum(pointOnAbovePlane, frustumPlanesWorld) && // Real point is in Frustum
-                                pointInFrustum(pointProjectedToFloor, frustumPlanesWorld) && // Projection on the floor too
-                                pointProjectedToFloor.x >= this.wallX.position.x - 0.01 &&
-                                pointProjectedToFloor.y >= this.sceneElevation - 0.01 && 
-                                pointProjectedToFloor.z >= this.wallY.position.z - 0.01) {
-                                tempProjectedToFloor.push(pointProjectedToFloor);
-                            }
+                            subjectPolygonProjected.push(projectedPoint);
+                        }
+                    });
+    
+                    sortByAngle(coveredPointsFloor, floorNormal);
+                    sortByAngle(subjectPolygonProjected, floorNormal);
+
+                    coveredPointsAbove = [];
+                    if (subjectPolygonProjected.length > 2 && coveredPointsFloor.length > 2) {
+                        
+                        // We cut the subject polygon (purple) by the cutting polygon (grey)
+                        const clippedProjectedPoints = sutherlandHodgmanClip(subjectPolygonProjected, coveredPointsFloor);
+
+                        clippedProjectedPoints.forEach(p => {
+                            p.y = this.sceneElevation;
                         });
 
-                        coveredPointsAbove = tempProjectedToFloor; // Ces points sont au niveau du sol de la tranche de détection
+                        coveredPointsAbove = clippedProjectedPoints;
+                    } else {
+                        coveredPointsAbove = [];
                     }
-    
-    
-                    sortByAngle(coveredPointsFloor, floorNormal);
-                    sortByAngle(coveredPointsAbove, floorNormal); // Triés au niveau du sol de la tranche
-                    sortByAngle(coveredPointsWallX, wallXNormal.clone().negate()); // Normale intérieure du mur X
-                    sortByAngle(coveredPointsWallY, wallYNormal.clone().negate()); // Normale intérieure du mur Y
+
+                    sortByAngle(coveredPointsAbove, floorNormal);
+                    sortByAngle(coveredPointsWallX, wallXNormal.clone().negate());
+                    sortByAngle(coveredPointsWallY, wallYNormal.clone().negate());
 
                 } else {
 
@@ -850,6 +858,80 @@ class SceneManager{
             }
 
         }
+ 
+        function getLineIntersection(p1, p2, p3, p4) {
+            const d = (p2.x - p1.x) * (p4.z - p3.z) - (p2.z - p1.z) * (p4.x - p3.x);
+            
+            // If lines are almost parallel, we don't compute to avoid mistakes
+            if (Math.abs(d) < 1e-10) {
+                return null;
+            }
+        
+            const t = ((p3.x - p1.x) * (p4.z - p3.z) - (p3.z - p1.z) * (p4.x - p3.x)) / d;
+        
+            // We check intersection is on one segment and an infinite line
+            if (t >= 0 && t <= 1) {
+                return new Vector3(p1.x + t * (p2.x - p1.x), p1.y, p1.z + t * (p2.z - p1.z));
+            }
+        
+            return null;
+        }
+        
+        
+        /**
+         * Cut a polygon with another
+         */
+        function sutherlandHodgmanClip(subjectPolygon, clipPolygon) {
+            let outputList = subjectPolygon;
+            const epsilon = 1e-6;
+        
+            for (let i = 0; i < clipPolygon.length; i++) {
+                const clipEdgeStart = clipPolygon[i];
+                const clipEdgeEnd = clipPolygon[(i + 1) % clipPolygon.length];
+                
+                const inputList = outputList;
+                outputList = [];
+                
+                if (inputList.length === 0) break;
+        
+                let S = inputList[inputList.length - 1];
+        
+                for (let j = 0; j < inputList.length; j++) {
+                    const E = inputList[j];
+                    
+                    // 2D normal rotated inward (assuming counterclockwise order)
+                    const normal = new Vector3(clipEdgeEnd.z - clipEdgeStart.z, 0, clipEdgeStart.x - clipEdgeEnd.x).negate();                    
+                    const isS_inside = new Vector3().subVectors(S, clipEdgeStart).dot(normal) >= -epsilon;
+                    const isE_inside = new Vector3().subVectors(E, clipEdgeStart).dot(normal) >= -epsilon;
+        
+                    if (isE_inside) {
+                        if (!isS_inside) {
+                            // S is out, E is in -> we add intersection
+                            const intersection = getLineIntersection(S, E, clipEdgeStart, clipEdgeEnd);
+                            if (intersection) { // !! CRUCIAL CHECK !!
+                                if (outputList.length === 0 || intersection.distanceTo(outputList[outputList.length - 1]) > epsilon) {
+                                    outputList.push(intersection);
+                                }
+                            }
+                        }
+                        // E is in -> we add it
+                        outputList.push(E);
+                    } else if (isS_inside) {
+                        // S is in, E is out -> we add intersection
+                        const intersection = getLineIntersection(S, E, clipEdgeStart, clipEdgeEnd);
+                        if (intersection) { // !! CRUCIAL CHECK !!
+                            if (outputList.length === 0 || intersection.distanceTo(outputList[outputList.length - 1]) > epsilon) {
+                                outputList.push(intersection);
+                            }
+                        }
+                    }
+                    // Both are out -> we don't add anything
+                    S = E;
+                }
+            }
+            return outputList;
+        }
+        
 
         /**
          * Get every intersection points of multiple rays