Ios swift – CoreMotion and how to update a reference CMAttitude?

Since there’s no API to create or modify instances of CMAttitude, the first step to is to create your own struct representing pitch, roll, and yaw.

struct MyAttitude {
    let pitch: Double
    let roll: Double
    let yaw: Double

    init(attitude: CMAttitude) {
        self.pitch = attitude.pitch
        self.roll = attitude.roll
        self.yaw = attitude.yaw
    }

    init(pitch: Double, roll: Double, yaw: Double) {
        self.pitch = pitch
        self.roll = roll
        self.yaw = yaw
    }
}

Next, you can create a class that contains the logic needed to calculate adjusted attitudes from the current reference attitude and the newest device attitude. This class can update the reference attitude when the user starts rotating back in the opposite direction after rotating beyond the maximum angle.

class ReferenceAttitude {
    var reference: MyAttitude
    var maxPitch = 0.0
    var minPitch = 0.0
    var maxRoll = 0.0
    var minRoll = 0.0
    var maxYaw = 0.0
    var minYaw = 0.0

    init(with attitude: CMAttitude) {
        reference = MyAttitude(pitch: attitude.pitch, roll: attitude.roll, yaw: attitude.yaw)
    }

    func relative(to attitude: CMAttitude, clampedTo angle: Double) -> MyAttitude {
        // Get the current relative attitude
        var pitch = attitude.pitch - reference.pitch
        var roll = attitude.roll - reference.roll
        var yaw = attitude.yaw - reference.yaw

        // Adjust the pitch as needed
        var newPitch: Double?
        // Is the pitch greater than the max angle?
        if (pitch > angle) {
            // Yes, are we still increasing?
            if (pitch >= maxPitch) {
                // Yes, track how far we've pitched so far
                maxPitch = pitch
            } else {
                // No, we maxed out and are now decreasing. Readjust to a new pitch reference
                newPitch = attitude.pitch - angle
                maxPitch = angle
                minPitch = 0
            }
            // Clamp the pitch
            pitch = angle
        // Is the pitch less than the min angle?
        } else if (pitch < -angle) {
            // Yes, are we still decreasing?
            if (pitch <= minPitch) {
                // Yes, track how far we've pitched so far
                minPitch = pitch
            } else {
                // No, we mined out and are now increasing. Readjust to a new pitch reference
                newPitch = attitude.pitch + angle
                minPitch = -angle
                maxPitch = 0
            }
            // Clamp the pitch
            pitch = -angle
        }

        // Same logic for roll as pitch
        var newRoll: Double?
        if (roll > angle) {
            if (roll >= maxRoll) {
                maxRoll = roll
            } else {
                newRoll = attitude.roll - angle
                maxRoll = angle
                minRoll = 0
            }
            roll = angle
        } else if (roll < -angle) {
            if (roll <= minRoll) {
                minRoll = roll
            } else {
                newRoll = attitude.roll + angle
                minRoll = -angle
                maxRoll = 0
            }
            roll = -angle
        }

        // Same logic for yaw as pitch
        var newYaw: Double?
        if (yaw > angle) {
            if (yaw >= maxYaw) {
                maxYaw = yaw
            } else {
                newYaw = attitude.yaw - angle
                maxYaw = angle
                minYaw = 0
            }
            yaw = angle
        } else if (yaw < -angle) {
            if (yaw <= minYaw) {
                minYaw = yaw
            } else {
                newYaw = attitude.yaw + angle
                minYaw = -angle
                maxYaw = 0
            }
            yaw = -angle
        }

        // Do we have any new reference values?
        if newPitch != nil || newRoll != nil || newYaw != nil {
            // Yes, create a new reference
            reference = MyAttitude(pitch: newPitch ?? reference.pitch, roll: newRoll ?? reference.roll, yaw: newYaw ?? reference.yaw)
        }

        // Return the new adjusted relative attitude
        return .init(pitch: pitch, roll: roll, yaw: yaw)
    }
}

Finally, your MyView can be updated to use this struct and class.

Change the declaration of referenceAttitude to:

private var referenceAttitude: ReferenceAttitude?

Then replace applyRotationEffect with:

private func applyRotationEffect(_ deviceMotion: CMDeviceMotion) {
    guard let referenceAttitude = self.referenceAttitude else {
        self.referenceAttitude = ReferenceAttitude(with: deviceMotion.attitude)
        return
    }

    let adjusted = referenceAttitude.relative(to: deviceMotion.attitude, clampedTo: maxRotation)

    var transform = CATransform3DIdentity
    transform.m34 = 1 / 500
    transform = CATransform3DRotate(transform, CGFloat(adjusted.pitch), 1, 0, 0)
    transform = CATransform3DRotate(transform, CGFloat(adjusted.roll), 0, 1, 0)
    transform = CATransform3DRotate(transform, CGFloat(adjusted.yaw), 0, 0, 1)

    layer.transform = transform
}

As an example, let’s say the user starts the app with the phone laying flat on table. While keeping the phone flat on the table, if the user starts rotating the phone clockwise, the yaw is being changed. If the phone is rotated up to 45º the view moves a corresponding amount. If the device keeps rotating clockwise, the view stays at its max rotation of 45º. But as soon as the device begins to rotate back counter-clockwise (anti-clockwise), the view begins to rotate back. No need to get back to 45º first for the view to start rotating again.

To test this out, create a new Swift/Storyboard project. Add the new struct and class from this answer. Add the OP’s MyView class with the changes from this answer. Then replace the stock ViewController implementation with the following:

class ViewController: UIViewController {
    var rotate = MyView()

    override func viewDidLoad() {
        super.viewDidLoad()

        view.backgroundColor = .black
        
        rotate.backgroundColor = .red
        rotate.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(rotate)
        NSLayoutConstraint.activate([
            rotate.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            rotate.centerYAnchor.constraint(equalTo: view.centerYAnchor),
            rotate.heightAnchor.constraint(equalToConstant: 300),
            rotate.widthAnchor.constraint(equalToConstant: 200),
        ])
    }
}

Run the app and rotate away.