ARKit中限制SCNNode显示距离的技术问题咨询

嘿，我之前也踩过SCNDistanceConstraint的这个坑！它确实能帮你限制节点和相机的距离，但麻烦就麻烦在它会直接修改节点的实际位置，等用户回到合适范围时，节点不会自动跳回原位对吧？

你的需求很明确：节点默认在原位，用户离得太近/太远时，保持朝向用户但距离被限制，用户回到正常范围后节点自动归位。下面给你两种靠谱的实现方案：

方案一：通过Renderer帧更新动态计算位置 #

这种方式直观，适合快速验证效果，核心思路是用一个父节点固定默认位置，动态调整子节点的位置，子节点始终朝向相机，同时距离被限制在你设定的区间内。

步骤1：设置节点层级 #

先创建一个父节点来固定默认位置，实际显示的节点作为它的子节点：

// 固定默认位置的父节点
let anchorNode = SCNNode()
anchorNode.position = SCNVector3(0, 0, 5) // 这里填你想要的默认原位
sceneView.scene.rootNode.addChildNode(anchorNode)

// 实际要显示的节点（比如一个球体）
let targetNode = SCNNode(geometry: SCNSphere(radius: 0.1))
anchorNode.addChildNode(targetNode)

步骤2：添加朝向约束 #

让节点始终对着用户（相机），保持方向不变：

let lookAtCamera = SCNLookAtConstraint(target: sceneView.pointOfView)
lookAtCamera.isGimbalLockEnabled = true // 避免出现奇怪的旋转
targetNode.constraints = [lookAtCamera]

步骤3：帧更新时计算并调整位置 #

实现SCNSceneRendererDelegate的方法，每一帧根据相机位置动态调整节点位置：

func renderer(_ renderer: SCNSceneRenderer, updateAtTime time: TimeInterval) {
    guard let camera = sceneView.pointOfView else { return }
    
    // 获取默认位置和相机位置
    let originalPos = anchorNode.worldPosition
    let cameraPos = camera.worldPosition
    
    // 计算相机到默认位置的方向向量和距离
    let direction = originalPos - cameraPos
    let currentDistance = direction.length()
    
    // 定义距离限制区间
    let minDistance: Float = 1.0 // 最小距离不小于1米
    let maxDistance: Float = 10.0 // 可根据需求设置最大距离
    
    // 限制距离在区间内
    let clampedDistance = max(min(currentDistance, maxDistance), minDistance)
    
    // 计算节点应该在的位置：相机位置 + 归一化方向 * 限制后的距离
    let normalizedDir = direction.normalized()
    let targetPos = cameraPos + normalizedDir * clampedDistance
    
    // 将世界坐标转换为父节点的本地坐标，确保节点始终以默认位置为参考
    targetNode.position = anchorNode.convertPosition(targetPos, from: nil)
}

辅助扩展方法 #

需要给SCNVector3加几个常用的计算扩展：

extension SCNVector3 {
    // 计算向量长度
    func length() -> Float {
        return sqrt(x*x + y*y + z*z)
    }
    
    // 归一化向量（长度变为1）
    func normalized() -> SCNVector3 {
        let len = length()
        return len == 0 ? self : SCNVector3(x/len, y/len, z/len)
    }
    
    // 向量加法
    static func + (lhs: SCNVector3, rhs: SCNVector3) -> SCNVector3 {
        return SCNVector3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z)
    }
    
    // 向量数乘
    static func * (lhs: SCNVector3, rhs: Float) -> SCNVector3 {
        return SCNVector3(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs)
    }
    
    // 向量减法
    static func - (lhs: SCNVector3, rhs: SCNVector3) -> SCNVector3 {
        return SCNVector3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z)
    }
}

方案二：自定义SCNConstraint（更优雅） #

如果觉得帧更新代码太散，可以把逻辑封装成自定义约束，这样代码更整洁，也方便复用：

class LockedDistanceConstraint: SCNConstraint {
    // 可配置的距离限制
    var minDistance: Float = 1.0
    var maxDistance: Float = 10.0
    // 弱引用相机，避免循环引用
    weak var cameraNode: SCNNode?
    
    override func copy(with zone: NSZone? = nil) -> Any {
        let copy = LockedDistanceConstraint()
        copy.minDistance = minDistance
        copy.maxDistance = maxDistance
        copy.cameraNode = cameraNode
        return copy
    }
    
    override func apply(to node: SCNNode, for renderer: SCNSceneRenderer) {
        guard let camera = cameraNode, let parentPos = node.parent?.worldPosition else { return }
        
        // 计算方向、距离，和方案一逻辑一致
        let cameraPos = camera.worldPosition
        let direction = parentPos - cameraPos
        let currentDistance = direction.length()
        let clampedDistance = max(min(currentDistance, maxDistance), minDistance)
        
        let normalizedDir = direction.normalized()
        let targetPos = cameraPos + normalizedDir * clampedDistance
        
        // 设置节点世界位置
        node.worldPosition = targetPos
        
        // 同时应用朝向约束，保持节点对着相机
        let lookAt = SCNLookAtConstraint(target: camera)
        lookAt.isGimbalLockEnabled = true
        lookAt.apply(to: node, for: renderer)
    }
}

// 使用方式
let distanceLock = LockedDistanceConstraint()
distanceLock.minDistance = 1.0
distanceLock.maxDistance = 10.0
distanceLock.cameraNode = sceneView.pointOfView
targetNode.constraints = [distanceLock]

为什么不用SCNDistanceConstraint？ #

SCNDistanceConstraint的问题在于，它会直接修改节点的worldPosition，相当于把节点“挪”到了约束后的位置，当相机回到正常范围时，约束不会主动把节点移回原位——因为此时节点已经在相机的minDistance位置，约束认为它符合要求，不会再调整。而我们的方案始终以原始默认位置为参考，动态计算节点应该在的位置，所以用户回到正常范围后，节点会自动回到原位。

内容的提问来源于stack exchange，提问作者Damian Dudycz