Structured 3D Model Collaboration in visionOS

import SwiftUI
import RealityKit

// MARK: - Clipping state machine
enum ClippingState {
    case off, on, editing
}

// MARK: - Custom component that caches last-edited bounds
struct ClippingBoundsCache: Component {
    var lastBounds: BoundingBox
    init(bounds: BoundingBox) { self.lastBounds = bounds }
}

// MARK: - SwiftUI view driving the experience
struct AssemblyClipperView: View {
    @State private var clippingState: ClippingState = .off
    @State private var rootEntity: Entity = makeAssembly()

    var body: some View {
        RealityView { content in
            content.add(rootEntity)
            // Attach manipulation to root so whole model moves together
            rootEntity.components.set(ManipulationComponent())
            rootEntity.components.set(InputTargetComponent())
            rootEntity.components.set(CollisionComponent(shapes: [.generateBox(size: [0.3, 0.3, 0.3])]))
        }
        .toolbar {
            ToolbarItemGroup(placement: .bottomOrnament) {
                Button("Off")    { applyClipping(.off) }
                Button("Clip")   { applyClipping(.on) }
                Button("Edit")   { applyClipping(.editing) }
            }
        }
    }

    // MARK: - State transitions
    private func applyClipping(_ newState: ClippingState) {
        clippingState = newState
        switch newState {
        case .off:
            // Cache current bounds then remove the clipping component
            if let existing = rootEntity.components[ClippingComponent.self] {
                rootEntity.components.set(ClippingBoundsCache(bounds: existing.bounds))
            }
            rootEntity.components.remove(ClippingComponent.self)

        case .on:
            // Restore or create a default clipping volume
            let bounds = rootEntity.components[ClippingBoundsCache.self]?.lastBounds
                ?? BoundingBox(min: [-0.15, -0.15, -0.15], max: [0.15, 0.15, 0.0])
            var clip = ClippingComponent(bounds: bounds)
            clip.shouldClipChildren = true  // NEW in visionOS 27 — must be true for child geometry
            clip.shouldClipSelf = true
            rootEntity.components.set(clip)

        case .editing:
            // Ensure clipping is active, then push the +Z face outward interactively
            applyClipping(.on)
            animateClipFaceZ(to: 0.12)
        }
    }

    // Animate the +Z clipping plane to a new position in model-local space
    private func animateClipFaceZ(to newMaxZ: Float) {
        guard var clip = rootEntity.components[ClippingComponent.self] else { return }
        let current = clip.bounds
        let updated = BoundingBox(
            min: current.min,
            max: SIMD3<Float>(current.max.x, current.max.y, newMaxZ)
        )
        clip.bounds = updated
        rootEntity.components.set(clip)
    }
}

// MARK: - Build a simple two-piece assembly
private func makeAssembly() -> Entity {
    let root = Entity()
    root.name = "AirPodsProAssembly"

    let colors: [(SIMD3<Float>, String)] = [
        ([0.9, 0.9, 0.9], "TopEnclosure"),
        ([0.7, 0.7, 0.75], "BottomEnclosure"),
        ([0.5, 0.5, 0.55], "LogicBoard")
    ]
    for (index, (color, name)) in colors.enumerated() {
        let mesh = MeshResource.generateBox(size: [0.08, 0.04, 0.02])
        var mat  = SimpleMaterial()
        mat.baseColor = .init(tint: .init(
            red: Double(color.x), green: Double(color.y), blue: Double(color.z), alpha: 1))
        let part = ModelEntity(mesh: mesh, materials: [mat])
        part.name = name
        part.position = [0, Float(index) * 0.05 - 0.05, 0]
        root.addChild(part)
    }
    return root
}