Converting Positions Between Local Coordinate Spaces.

[Reality-Dev]

Coming from RealityKit I am used to using methods on the TransformComponent like these, where transform values can be retrieved and set relative to any other Entity in the scene graph:

• position(relativeTo referenceEntity: Entity?) -> SIMD3<Float>
• setPosition(
  _ position: SIMD3<Float>,
  relativeTo referenceEntity: Entity?
  )
• orientation(relativeTo referenceEntity: Entity?)
• setOrientation(
  _ orientation: simd_quatf,
  relativeTo referenceEntity: Entity?
  )
• scale(relativeTo referenceEntity: Entity?) -> SIMD3<Float>
• setScale(
  _ scale: SIMD3<Float>,
  relativeTo referenceEntity: Entity?
  )

And methods like these that can convert from one Entity's local coordinate space to another Entity's local coordinate space:

• convert(
  position: SIMD3<Float>,
  to referenceEntity: Entity?
  ) -> SIMD3<Float>
• convert(
  position: SIMD3<Float>,
  from referenceEntity: Entity?
  ) -> SIMD3<Float>

Out of necessity, and as a start, I have created a couple of these for Satin:

public extension Object {
    /// Converts a position from the local space of the Object on which you called this method to the local space of a reference Object.
    /// - Parameters:
    ///   - position: The position given in the local space of the Object.
    ///   - referenceObject: The Object that defines a frame of reference.
    /// - Returns: The position specified relative to referenceObject.
    func convertPosition(_ position: simd_float3, to referenceObject: Object) -> simd_float3 {
        let worldSpacePosition = (self.worldMatrix * simd_float4x4(translation: position)).translation
        return (referenceObject.worldMatrix.inverse * simd_float4x4(translation: worldSpacePosition)).translation
    }
    
    
    /// Gets the position of an Object relative to the given Object.
    /// - Parameter referenceObject: The Object that defines a frame of reference.
    /// - Returns: The position of the Object relative to referenceObject.
    func position(relativeTo referenceObject: Object) -> simd_float3 {
        return (referenceObject.worldMatrix.inverse * simd_float4x4(translation: self.worldPosition)).translation
    }
}

[Reality-Dev]

Here are some updates, including the ability to use nil to indicate world space.

    /// Converts a position from the local space of the Object on which you called this method to the local space of a reference Object.
    /// - Parameters:
    ///   - position: The position given in the local space of the Object.
    ///   - referenceObject: The Object that defines a frame of reference. Set this to nil to indicate world space.
    /// - Returns: The position specified relative to referenceObject.
    func convertPosition(_ position: simd_float3, to referenceObject: Object?) -> simd_float3 {
        let worldSpacePosition = (self.worldMatrix * simd_float4x4(translation: position)).translation
        
        if let referenceObject = referenceObject {
            return (referenceObject.worldMatrix.inverse * simd_float4x4(translation: worldSpacePosition)).translation
        } else {
            return worldSpacePosition
        }
    }
    
    /// Converts a position from the local space of a reference Object to the local space of the Object on which you called this method.
    /// - Parameters:
    ///   - position: The position specified relative to referenceObject.
    ///   - referenceObject: The Object that defines a frame of reference. Set this to nil to indicate world space.
    /// - Returns: The position given in the local space of the Object.
    func convertPosition(_ position: SIMD3<Float>, from referenceObject: Object?) -> SIMD3<Float> {
        var worldSpacePosition = position
        if let referenceObject = referenceObject {
            worldSpacePosition = (referenceObject.worldMatrix * simd_float4x4(translation: position)).translation
        }
        return (self.worldMatrix.inverse * simd_float4x4(translation: worldSpacePosition)).translation
    }

[Reality-Dev]

Here are some updates for converting direction vectors.

    /// Converts a direction vector from the local space of the Object on which you called this method to the local space of a reference Object.
    /// - Parameters:
    ///   - direction: The direction vector given in the local space of the Object.
    ///   - referenceObject: The Object that defines a frame of reference. Set this to nil to indicate world space.
    /// - Returns: The direction vector specified relative to referenceObject.
    func convert(
        direction: SIMD3<Float>,
        to referenceObject: Object?
    ) -> SIMD3<Float> {
        let worldSpaceDirection = worldOrientation.act(direction)

        if let referenceObject = referenceObject {
            return referenceObject.worldMatrix.inverse.orientation.act(worldSpaceDirection)
        } else {
            return worldSpaceDirection
        }
    }
    
    /// Converts a direction vector from the local space of a reference Object to the local space of the Object on which you called this method.
    /// - Parameters:
    ///   - direction: The direction vector specified relative to referenceObject.
    ///   - referenceObject: The Object that defines a frame of reference. Set this to nil to indicate world space.
    /// - Returns: The direction vector given in the local space of the Object.
    func convert(
        direction: SIMD3<Float>,
        from referenceObject: Object?
    ) -> SIMD3<Float> {
        var worldSpaceDirection = direction
        if let referenceObject = referenceObject {
            worldSpaceDirection = referenceObject.worldOrientation.act(direction)
        }
        return self.worldMatrix.inverse.orientation.act(worldSpaceDirection)
    }

[rezaali]

Thanks @Reality-Dev... these functions have been integrated into Satin's Object class. There were some changes I made, so please let me know if they work for you.