Reality Composer Pro 3 Plugin Extensions

import RealityKit
import RealityComposerPro

// MARK: - Custom Component

struct CauldronComponent: Component, Codable {
    var waterLevel: Float = 0.5       // 0.0 = empty, 1.0 = full
    var rotationSpeed: Float = 0.0    // radians per second
    var vortexCoefficient: Float = 0.0
}

// MARK: - Custom System

final class CauldronSystem: System {

    static let query = EntityQuery(where: .has(CauldronComponent.self))

    required init(scene: Scene) {}

    func update(context: SceneUpdateContext) {
        for entity in context.entities(matching: Self.query, updatingSystemWhen: .rendering) {
            guard let cauldron = entity.components[CauldronComponent.self],
                  let waterMesh = entity.findEntity(named: "WaterSurface") else { continue }

            // Lift the water plane based on the waterLevel property
            let baseY: Float = -0.1
            let rangeY: Float = 0.2
            waterMesh.position.y = baseY + cauldron.waterLevel * rangeY
        }
    }
}

// MARK: - Plugin Entry Point

final class CauldronPlugin: RealityComposerProPlugin {

    required init() {}

    func setup(context: RealityComposerProPluginContext) {
        // Register the component so it appears in the editor's component browser
        context.registerComponent(CauldronComponent.self)
        // Register the system so it runs live inside the editor viewport
        context.registerSystem(CauldronSystem.self)
    }
}

// Exported C entry point so the plugin loader can instantiate the plugin
@_cdecl("createRealityComposerProPlugin")
public func createRealityComposerProPlugin() -> UnsafeMutableRawPointer {
    Unmanaged.passRetained(CauldronPlugin()).toOpaque()
}

// MARK: - Custom Animation Action

struct WaterLevelAction: EntityAction, Codable {
    var startLevel: Float
    var endLevel: Float

    // EntityAction requirement: declare the value type used for interpolation
    static var animatedValueType: (any AnimatableData.Type)? { return nil }

    static func subscribe(to scene: Scene) {
        EntityAction.subscribe(to: WaterLevelAction.self, on: scene) { event in
            guard var cauldron = event.entity.components[CauldronComponent.self] else { return }
            cauldron.waterLevel = event.action.startLevel +
                Float(event.animationState.normalizedTime) *
                (event.action.endLevel - event.action.startLevel)
            event.entity.components.set(cauldron)
        }
    }
}