修复:重构墙洞修改器

src/DatabaseServices/Room/ParseService/Hole/RoomIHoleParseAndModify.ts

@@ -1,5 +1,8 @@
-import { Vector3 } from "three";
+import { MathUtils, Vector3 } from "three";
+import { arrayLast } from "../../../../Common/ArrayExt";
+import { CurveMap, Route } from "../../../../Geometry/CurveMap";
 import { GetHoleLengthOfIndex } from "../../../../Reactor/RoomHoleReactor";
+import { Curve } from "../../../Entity/Curve";
 import { RoomHolePolyline } from "../../Entity/Wall/Hole/RoomHolePolyline";
 import { RoomWallBase } from "../../Entity/Wall/RoomWallBase";
 import { RoomWallLine } from "../../Entity/Wall/RoomWallLine";
@@ -243,55 +246,93 @@ export class RoomLHoleParseAndModify
     MaxRightDist: number;
     MinLeftDist: number;
     MinRightDist: number;
-    leftDir: Vector3;
-    rightDir: Vector3;
+
+    r1IsReverse: boolean;
+    r2IsReverse: boolean;
 
     constructor(public hole: RoomHolePolyline)
     {
         let wall1 = hole.RelevancyWalls[0].Object;
         let wall2 = hole.RelevancyWalls[hole.RelevancyWalls.length - 1].Object;
 
-        let getParam1 = CreateGetCurveParam(wall1);
-        let getParam2 = CreateGetCurveParam(wall2);
+        let curvemap = new CurveMap();
+        for (let w of hole.RelevancyWalls)
+            curvemap.AddCurveToMap(w.Object as unknown as Curve, false, false, false);
 
         let pts = hole.Points;
-        let p1 = pts[0];
-        let p2 = pts[pts.length - 1];
 
-        let param1 = getParam1.GetParamAtPoint(p1);
-        let param2 = getParam2.GetParamAtPoint(p2);
+        let r1: Route;
+        let r2: Route;
+        if (pts.length === 3)
+        {
+            let v = curvemap._Vertices.find(v => v.routes.length === 2);
+            r1 = v.routes.find(r => r.curve === wall1 as unknown as Curve);
+            r2 = v.routes.find(r => r.curve === wall1 as unknown as Curve);
+        }
+        else if (pts.length === 4)
+        {
+            let v1 = curvemap._Vertices.find(v => v.routes.length === 2 && v.routes.some(r => r.curve === wall1 as unknown as Curve));
+            let v2 = curvemap._Vertices.find(v => v.routes.length === 2 && v.routes.some(r => r.curve === wall2 as unknown as Curve));
+
+            r1 = v1.routes.find(r => r.curve === wall1 as unknown as Curve);
+            r2 = v2.routes.find(r => r.curve === wall2 as unknown as Curve);
+        }
+
+        this.r1IsReverse = r1.isReverse;
+        this.r2IsReverse = r2.isReverse;
+
+        let getParam1 = CreateGetCurveParam(wall1);
+        let getParam2 = CreateGetCurveParam(wall2);
 
         let ranges1 = ParseWallRange(wall1, getParam1);
         let ranges2 = ParseWallRange(wall2, getParam2);
 
-        let range1 = FindBestRange(param1, ranges1);
-        let range2 = FindBestRange(param2, ranges2);
+        if (r1.isReverse)
+        {
+            this.MaxLeftDist = wall1.Length * ranges1[0][1];
+            this.MinLeftDist = wall1.Length * ranges1[0][0];
+        }
+        else
+        {
+            this.MaxLeftDist = wall1.Length * (1 - arrayLast(ranges1)[0]);
+            this.MinLeftDist = wall1.Length * (1 - arrayLast(ranges1)[1]);
+        }
 
-        this.MaxLeftDist = (range1[1] - range1[0]) * wall1.Length;
-        this.MaxRightDist = (range2[1] - range2[0]) * wall2.Length;
-        this.MinLeftDist = (range1[0] < 0.2 ? range1[0] * wall1.Length : (1 - range1[1]) * wall1.Length) + 100;
-        this.MinRightDist = (range2[0] < 0.2 ? range2[0] * wall2.Length : (1 - range2[1]) * wall2.Length) + 100;
+        if (r2.isReverse)
+        {
+            this.MaxRightDist = wall2.Length * (1 - arrayLast(ranges2)[0]);
+            this.MinRightDist = wall2.Length * (1 - arrayLast(ranges2)[1]);
+        }
+        else
+        {
+            this.MaxRightDist = wall2.Length * ranges2[0][1];
+            this.MinRightDist = wall2.Length * ranges2[0][0];
+        }
 
         this._LeftDist = GetHoleLengthOfIndex(hole, 0);
-        this._RightDist = GetHoleLengthOfIndex(hole, 1);
+        this._RightDist = GetHoleLengthOfIndex(hole, hole.RelevancyWalls.length - 1);
 
         this._BottomDist = hole.Z - wall1.Z;
         this._TopDist = wall1.Height - hole.Height - this._BottomDist;
 
         this._Wall = wall1;
-
-        this.leftDir = pts[0].clone().sub(pts[1]).normalize();
-        this.rightDir = pts[pts.length - 1].clone().sub(pts[pts.length - 2]).normalize();
     }
 
     get LeftDist() { return this._LeftDist; }
     set LeftDist(value: number)
     {
-        if (value > this.MaxLeftDist) value = this.MaxLeftDist;
-        else if (value < this.MinLeftDist) value = this.MinLeftDist;
-
+        value = MathUtils.clamp(value, this.MinLeftDist, this.MaxLeftDist);
         let pts = this.hole.Points;
-        pts[0].copy(pts[1]).add(this.leftDir.clone().multiplyScalar(value));
+
+        let wall = this.hole.RelevancyWalls[0].Object;
+
+        if (this.r1IsReverse)
+            pts[0] = wall.GetPointAtDistance(wall.Length - value);
+        else
+            pts[0] = wall.GetPointAtDistance(value);
+
+        pts[0].z = pts[1].z;
+
         this.hole.Points = pts;
         this._LeftDist = value;
     }
@@ -299,11 +340,18 @@ export class RoomLHoleParseAndModify
     get RightDist() { return this._RightDist; }
     set RightDist(value: number)
     {
-        if (value > this.MaxRightDist) value = this.MaxRightDist;
-        else if (value < this.MinRightDist) value = this.MinRightDist;
+        value = MathUtils.clamp(value, this.MinRightDist, this.MaxRightDist);
 
         let pts = this.hole.Points;
-        pts[pts.length - 1].copy(pts[pts.length - 2]).add(this.rightDir.clone().multiplyScalar(value));
+        let wall = this.hole.RelevancyWalls[this.hole.RelevancyWalls.length - 1].Object;
+
+        if (this.r2IsReverse)
+            pts[pts.length - 1] = wall.GetPointAtDistance(wall.Length - value);
+        else
+            pts[pts.length - 1] = wall.GetPointAtDistance(value);
+
+        pts[pts.length - 1].z = pts[0].z;
+
         this.hole.Points = pts;
         this._RightDist = value;
     }