스위프트 로프 Verlets

Question

신속한 로프 로프를 구현하려고합니다. 제약에서 point masses의 위치를 ​​고치려고 할 때, 그것들은 매우 빠르게 떨어져 나간다. 그리고 나서 좌표는 NaN이된다. 내 코드에서 무엇이 잘못 될 수 있습니까?

import Foundation 

private let DEF_POINT_COUNT = 10 
private let CONST_ITERATIONS = 5 

@objc class PointMass: DebugPrintable { 
    var point: NSPoint 
    private var oldPoint: NSPoint 

    var x: Double { 
     get { return Double(point.x) } 
    } 

    var y: Double { 
     get { return Double(point.y) } 
    } 

    var debugDescription: String { 
     get { return "\(point)" } 
    } 

    init(_ point: NSPoint) { 
     self.point = point 
     self.oldPoint = point 
    } 

    func updatePosition() { 
     let dx = point.x - oldPoint.x 
     let dy = (point.y - oldPoint.y) 

     oldPoint = point 

     point = NSPoint(x: point.x + dx, y: point.y + dy) 
    } 

    func updatePosition(point: NSPoint) { 
     let dx = point.x - self.point.x 
     let dy = point.y - self.point.y 
     self.oldPoint = NSPoint(x: oldPoint.x + dx, y: oldPoint.y + dy) 
     self.point = point 
    } 
} 

struct Constraint { 
    var p1: PointMass 
    var p2: PointMass 
    var len: Double 

    func fixPoints() { 
     let dx = p2.x - p1.x 
     let dy = p2.y - p1.y 

     let dist = sqrt(dx*dx + dy*dy) 

     let diff = (dist - len)/len 

     p2.updatePosition(NSPoint(x: p2.x - diff*dx*0.5, y: p2.y - diff*dy*0.5)) 
     p1.updatePosition(NSPoint(x: p1.x + diff*dx*0.5, y: p1.y + diff*dy*0.5)) 
    } 
} 

@objc class Rope: NSObject { 
    let points: [PointMass] 
    let constraints: [Constraint] 

    init(anchor: NSPoint, end: NSPoint, length: Double, count: Int = DEF_POINT_COUNT) { 
     let anchorPoint = PointMass(anchor) 
     let endPoint = PointMass(end) 

     let dx = (anchorPoint.x - endPoint.x)/Double(count) 
     let dy = (anchorPoint.y - endPoint.y)/Double(count) 

     let constraintLength = length/Double(count) 

     var points = [endPoint] 
     var constraints: [Constraint] = [] 

     for i in 1...count { 
      let prevPoint = points[i-1] 
      let newPoint = PointMass(NSPoint(x: prevPoint.x + dx, y: prevPoint.y + dy)) 

      let constraint = Constraint(p1: prevPoint, p2: newPoint, len: constraintLength) 

      points.append(newPoint) 
      constraints.append(constraint) 
     } 

     self.points = points 
     self.constraints = constraints 
    } 

    func update(anchor: NSPoint, endPoint: NSPoint) { 
     points.first?.updatePosition(endPoint) 
     points.last?.updatePosition(anchor) 

     for point in points { 
      point.updatePosition() 
     } 

     for i in 0...CONST_ITERATIONS { 
      for constraint in constraints { 
       constraint.fixPoints() 
      } 
     } 
    } 
} 

Answer 1

발견. 문제는 fixPoints() 메서드에서 발생했습니다.

라인

let diff = (dist - len)/len 

대신

let diff = (len - dist)/dist 

되어야