What's new in _RealityKit_ComputeGraph

public struct BufferInfo {

    public init(buffer: any MTLBuffer, bufferOffset: Int = 0, elementCount: Int)
}

public struct ComputeGraphComponent : Component {

    /// Creates a `ComputeGraphComponent` with no resource attached.
    public init()
}

extension ComputeGraphComponent.SimulationState : Equatable {
}

extension ComputeGraphComponent.SimulationState : Hashable {
}

public struct ComputeGraphOutputComponent : TransientComponent {

    /// The identifier of the output node in the compute graph that this entity
    /// represents.
    public var outputID: ComputeNodeGraph.NodeID { get }
}

public struct ComputeGraphRuntimeComponent : TransientComponent {
}

extension ComputeGraphSharedUniforms {

    /// Stores a uniform value, replacing any previously stored value of the same type.
    ///
    /// - Parameter value: The value to store. Must conform to `BitwiseCopyable`.
    public func setUniform<V>(_ value: borrowing V) where V : BitwiseCopyable

    /// Returns the stored uniform value for the given type, or `nil` if none has been set.
    ///
    /// - Parameter type: The `BitwiseCopyable` type to retrieve.
    /// - Returns: The stored value, or `nil`.
    public func uniform<V>(_ type: V.Type) -> V? where V : BitwiseCopyable

    /// Registers a closure that transforms a uniform value of type `V` on a per-entity basis.
    ///
    /// The closure receives the current value and the entity being evaluated,
    /// and returns the transformed value. This lets you derive per-entity
    /// variants of a global uniform at simulation time, for example, converting
    /// a position from the scene's coordinate system to the system's coordinate system.
    ///
    /// - Parameter transform: A closure `(V, Entity) -> V`.
    public func setUniformTransform<V>(_ transform: @escaping (V, Entity) -> V) where V : BitwiseCopyable

    /// Registers a raw-data transformer closure for a uniform of type `V`.
    ///
    /// Use this overload when the transformation is most naturally expressed
    /// over the raw byte representation of the value.
    ///
    /// - Parameters:
    ///   - type: The `BitwiseCopyable` type the transformer operates on.
    ///   - transform: A closure `(inout MutableRawSpan, Entity) -> Void`.
    public func setUniformTransform<V>(type: V.Type, transform: @escaping @_lifetime(0: copy 0) (inout MutableRawSpan, Entity) -> Void) where V : BitwiseCopyable
}

public struct ComputeGraphViewpointComponent : TransientComponent {

    /// The direction the observer is facing, in world space.
    public var viewDirection: SIMD3<Float>?

    /// The position of the observer, in world space.
    public var viewPosition: SIMD3<Float>?

    public init()
}

public struct ParameterHandle {
}

public enum SimulationState {

    /// The simulation advances each frame at its configured rate.
    case playing

    /// The simulation is frozen; no steps are evaluated.
    case paused

    /// The simulation evaluates exactly one step on the next frame, then returns to ``paused``.
    case stepping

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (a: ComputeGraphComponent.SimulationState, b: ComputeGraphComponent.SimulationState) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

public struct UniformHandle {
}

public struct Dependencies {

    public init()

    public var outputMaterials: [ComputeNodeGraph.NodeID : any Material]

    public var outputModels: [ComputeNodeGraph.NodeID : ModelComponent]

    public var textures: [ComputeNodeGraph.Port.Address : TextureResource]

    public var buffers: [ComputeNodeGraph.Port.Address : ComputeGraphResource.BufferInfo]
}