@galacean/engine-core 1.1.0-beta.2 → 1.1.0-beta.21

package/types/particle/moudules/ParticleCurve.d.ts

@@ -1,27 +1,11 @@
-import { IClone } from "@galacean/engine-design";
 import { ParticleCurveMode } from "../enums/ParticleCurveMode";
 /**
  * Particle curve.
  */
-export declare class ParticleCurve implements IClone {
+export declare class ParticleCurve {
     /** The curve mode. */
     mode: ParticleCurveMode;
     constant: number;
     constantMin: number;
     constantMax: number;
-    /**
-     * Query the curve value at the specified time.
-     * @param time - Normalized time at which to evaluate the curve, Valid when `mode` is set to `Curve` or `TwoCurves`
-     * @param lerpFactor - Lerp factor between two constants or curves, Valid when `mode` is set to `TwoConstants` or `TwoCurves`
-     * @returns - The result curve value
-     */
-    evaluate(time: number, lerpFactor: number): number;
-    /**
-     * @inheritDoc
-     */
-    cloneTo(destEmission: ParticleCurve): void;
-    /**
-     * @inheritDoc
-     */
-    clone(): ParticleCurve;
 }

package/types/physics/Collider.d.ts

@@ -1,11 +1,12 @@
 import { BoolUpdateFlag } from "../BoolUpdateFlag";
 import { Component } from "../Component";
 import { ColliderShape } from "./shape/ColliderShape";
+import { ICustomClone } from "../clone/ComponentCloner";
 /**
  * Base class for all colliders.
  * @decorator `@dependentComponents(Transform, DependentMode.CheckOnly)`
  */
-export declare class Collider extends Component {
+export declare class Collider extends Component implements ICustomClone {
     protected _updateFlag: BoolUpdateFlag;
     protected _shapes: ColliderShape[];
     /**
@@ -26,4 +27,5 @@ export declare class Collider extends Component {
      * Remove all shape attached.
      */
     clearShapes(): void;
+    protected _addPhysicsShape(shape: ColliderShape): void;
 }

package/types/physics/PhysicsManager.d.ts

@@ -9,7 +9,6 @@ export declare class PhysicsManager {
     private static _collision;
     private _engine;
     private _restTime;
-    private _fixedTimeStep;
     private _colliders;
     private _gravity;
     private _nativePhysicsManager;
@@ -20,14 +19,13 @@ export declare class PhysicsManager {
     private _onTriggerEnter;
     private _onTriggerExit;
     private _onTriggerStay;
+    /** The fixed time step in seconds at which physics are performed. */
+    fixedTimeStep: number;
     /**
      * The gravity of physics scene.
      */
     get gravity(): Vector3;
     set gravity(value: Vector3);
-    /** The fixed time step in seconds at which physics are performed. */
-    get fixedTimeStep(): number;
-    set fixedTimeStep(value: number);
     constructor(engine: Engine);
     /**
      * Casts a ray through the Scene and returns the first hit.

package/types/physics/PhysicsMaterial.d.ts

@@ -8,6 +8,7 @@ export declare class PhysicsMaterial {
     private _staticFriction;
     private _bounceCombine;
     private _frictionCombine;
+    private _destroyed;
     constructor();
     /**
      * The coefficient of bounciness.

package/types/physics/joint/HingeJoint.d.ts

@@ -28,7 +28,7 @@ export declare class HingeJoint extends Joint {
     /**
      * The angular velocity of the joint in degrees per second.
      */
-    get velocity(): Readonly<Vector3>;
+    get velocity(): Readonly<number>;
     /**
      * Enables the joint's limits. Disabled by default.
      */

package/types/physics/joint/Joint.d.ts

@@ -3,13 +3,14 @@ import { Vector3 } from "@galacean/engine-math";
 import { Component } from "../../Component";
 import { Entity } from "../../Entity";
 import { Collider } from "../Collider";
+import { ICustomClone } from "../../clone/ComponentCloner";
 /**
  * A base class providing common functionality for joints.
  * @decorator `@dependentComponents(Collider, DependentMode.CheckOnly)`
  */
-export declare class Joint extends Component {
-    protected _connectedCollider: JointCollider;
-    protected _collider: JointCollider;
+export declare class Joint extends Component implements ICustomClone {
+    protected _colliderInfo: JointColliderInfo;
+    protected _connectedColliderInfo: JointColliderInfo;
     protected _nativeJoint: IJoint;
     private _force;
     private _torque;

package/types/physics/shape/ColliderShape.d.ts

@@ -1,10 +1,11 @@
 import { PhysicsMaterial } from "../PhysicsMaterial";
 import { Vector3 } from "@galacean/engine-math";
 import { Collider } from "../Collider";
+import { ICustomClone } from "../../clone/ComponentCloner";
 /**
  * Abstract class for collider shapes.
  */
-export declare abstract class ColliderShape {
+export declare abstract class ColliderShape implements ICustomClone {
     private static _idGenerator;
     protected _id: number;
     protected _material: PhysicsMaterial;

package/types/physics/shape/SphereColliderShape.d.ts

@@ -10,4 +10,5 @@ export declare class SphereColliderShape extends ColliderShape {
     get radius(): number;
     set radius(value: number);
     constructor();
+    _cloneTo(target: SphereColliderShape): void;
 }

package/types/shader/Shader.d.ts

@@ -19,7 +19,7 @@ export declare class Shader {
      * // Import shaderLab
      * import { ShaderLab } from "@galacean/engine-shader-lab";
      * // Create engine with shaderLab
-     * const engine = await WebGLEngine.create({ canvas: "canvas", new ShaderLab() });
+     * const engine = await WebGLEngine.create({ canvas: "canvas", shader: new ShaderLab() });
      * ...
      * ```
      *

package/types/xr/IXRDevice.d.ts

@@ -0,0 +1,26 @@
+import { IXRSession, IXRFeatureDescriptor, IXRPlatformFeature } from "@galacean/engine-design";
+import { Engine } from "../Engine";
+import { XRSessionType } from "./session/XRSessionType";
+/**
+ * The interface of XR device.
+ */
+export interface IXRDevice {
+    /**
+     * Whether the device is supported.
+     * @param mode - The mode of the session.
+     */
+    isSupported(mode: XRSessionType): Promise<void>;
+    /**
+     * Get the platform feature instance of this device
+     * @param engine - The engine.
+     * @param type - The type of the feature.
+     */
+    createPlatformFeature(engine: Engine, type: number): IXRPlatformFeature;
+    /**
+     * Request a session.
+     * @param engine - The engine
+     * @param mode - The mode of the session
+     * @param requestFeatures - The requested features
+     */
+    requestSession(engine: Engine, mode: XRSessionType, requestFeatures: IXRFeatureDescriptor[]): Promise<IXRSession>;
+}

package/types/xr/XRManager.d.ts

@@ -1,31 +1,98 @@
+import { IXRFeatureDescriptor, IXRPlatformFeature } from "@galacean/engine-design";
+import { XRInputManager } from "./input/XRInputManager";
+import { XRFeatureType } from "./feature/XRFeatureType";
+import { XRSessionManager } from "./session/XRSessionManager";
+import { XRSessionType } from "./session/XRSessionType";
+import { XRFeatureManager } from "./feature/XRFeatureManager";
+import { IXRDevice } from "./IXRDevice";
 import { Engine } from "../Engine";
-import { EnumXRMode } from "./enum/EnumXRMode";
-import { EnumXRFeature } from "./enum/EnumXRFeature";
-import { EnumXRTrackingMode } from "./enum/EnumXRTrackingMode";
-import { XRFeature } from "./feature/XRFeature";
-import { EnumXRSubsystem } from "./enum/EnumXRSubsystem";
-import { XRProvider } from "./provider/XRProvider";
-import { XRSubsystem } from "./subsystem/XRSubsystem";
-type FeatureConstructor = new (engine: Engine) => XRFeature;
+import { Scene } from "../Scene";
+import { Entity } from "../Entity";
+type TXRFeatureManager = XRFeatureManager<IXRFeatureDescriptor, IXRPlatformFeature>;
+type TXRFeatureManagerConstructor = new (engine: Engine) => TXRFeatureManager;
+/**
+ * XRManager is the entry point of the XR system.
+ */
 export declare class XRManager {
+    /** Hardware adaptation for XR. */
+    xrDevice: IXRDevice;
+    /** Input manager for XR. */
+    inputManager: XRInputManager;
+    /** Session manager for XR. */
+    sessionManager: XRSessionManager;
     private _engine;
-    private _provider;
+    private _scene;
+    private _origin;
     private _features;
-    private _subsystems;
-    private _isPaused;
-    isSupportedMode(mode: EnumXRMode): Promise<void>;
-    isSupportedTrackingMode(mode: EnumXRTrackingMode): Promise<void>;
-    isSupportedFeature(feature: EnumXRFeature): Promise<void>;
-    getFeature<T extends XRFeature>(feature: EnumXRFeature): T;
-    enableFeature(feature: EnumXRFeature): void;
-    disableFeature(feature: EnumXRFeature): void;
-    getSubsystem<T extends XRSubsystem>(subsystem: EnumXRSubsystem): T;
-    initialize(mode: EnumXRMode, trackingMode: EnumXRTrackingMode, requestFeatures?: EnumXRFeature[]): Promise<void>;
-    start(): Promise<void>;
-    pause(): void;
-    resume(): void;
+    private _mode;
+    private _requestFeatures;
+    /**
+     * The current xr scene.
+     */
+    get scene(): Scene;
+    set scene(value: Scene);
+    /**
+     * The current xr origin.
+     */
+    get origin(): Entity;
+    set origin(value: Entity);
+    /**
+     * The current session mode( AR or VR ).
+     */
+    get mode(): XRSessionType;
+    /**
+     * The requested features.
+     */
+    get requestFeatures(): IXRFeatureDescriptor[];
+    /**
+     * Check if the specified mode is supported.
+     * @param mode - The mode to check
+     * @returns A promise that resolves if the mode is supported, otherwise rejects
+     */
+    isSupported(mode: XRSessionType): Promise<void>;
+    /**
+     * Check if the specified feature is supported.
+     * @param descriptors - The feature descriptor to check
+     * @returns A promise that resolves if the feature is supported, otherwise rejects
+     */
+    isSupportedFeature(descriptors: IXRFeatureDescriptor | IXRFeatureDescriptor[]): Promise<void>;
+    /**
+     * Disable all features.
+     */
+    disableAllFeatures(): void;
+    /**
+     * Get the feature instance.
+     * @param type - The type of feature
+     * @returns The feature instance
+     */
+    getFeature<T extends XRFeatureManager>(type: XRFeatureType): T;
+    /**
+     * Initialize the session.
+     * @param mode - The mode of the session
+     * @param requestFeatures - The requested features
+     * @returns A promise that resolves if the session is initialized, otherwise rejects
+     */
+    initSession(mode: XRSessionType, requestFeatures?: IXRFeatureDescriptor[]): Promise<void>;
+    /**
+     * Destroy the session.
+     * @returns A promise that resolves if the session is destroyed, otherwise rejects
+     */
+    destroySession(): Promise<void>;
+    /**
+     * Start the session.
+     * @returns A promise that resolves if the session is started, otherwise rejects
+     */
+    startSession(): Promise<void>;
+    /**
+     * Stop the session.
+     * @returns A promise that resolves if the session is stopped, otherwise rejects
+     */
+    stopSession(): Promise<void>;
+    /**
+     * Destroy xr module.
+     */
     destroy(): void;
-    constructor(engine: Engine, type: new (engine: Engine) => XRProvider);
+    constructor(engine: Engine, xrDevice: IXRDevice);
 }
-export declare function registerFeature(feature: EnumXRFeature, dependentSubsystem?: EnumXRSubsystem[]): (featureConstructor: FeatureConstructor) => void;
+export declare function registerXRFeatureManager(feature: XRFeatureType): (featureManagerConstructor: TXRFeatureManagerConstructor) => void;
 export {};

package/types/xr/feature/XRFeatureManager.d.ts

@@ -0,0 +1,65 @@
+import { IXRFeatureDescriptor, IXRFeatureManager, IXRPlatformFeature } from "@galacean/engine-design";
+import { Engine } from "../../Engine";
+/**
+ * The base class of XR feature manager.
+ */
+export declare abstract class XRFeatureManager<TDescriptor extends IXRFeatureDescriptor = IXRFeatureDescriptor, TPlatformFeature extends IXRPlatformFeature = IXRPlatformFeature> implements IXRFeatureManager {
+    protected _engine: Engine;
+    _platformFeature: TPlatformFeature;
+    protected _descriptor: TDescriptor;
+    protected _enabled: boolean;
+    /**
+     * Return the descriptor of the feature.
+     */
+    get descriptor(): TDescriptor;
+    set descriptor(value: TDescriptor);
+    /**
+     * Returns whether the feature is enabled.
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /**
+     * Returns whether the feature is supported.
+     * @param descriptor - The descriptor of the feature
+     * @returns The promise of the feature
+     */
+    isSupported(descriptor?: IXRFeatureDescriptor): Promise<void>;
+    /**
+     * Initialize the feature.
+     * @returns The promise of the feature
+     */
+    initialize(): Promise<void>;
+    /**
+     * Called when be enabled.
+     */
+    onEnable(): void;
+    /**
+     * Called when be disabled.
+     */
+    onDisable(): void;
+    /**
+     * Called when xr frame is updated.
+     */
+    onUpdate(): void;
+    /**
+     * Called when the session is initialized.
+     */
+    onSessionInit(): void;
+    /**
+     * Called when session starts.
+     */
+    onSessionStart(): void;
+    /**
+     * Called when the session is stopped.
+     */
+    onSessionStop(): void;
+    /**
+     * Called when the session is destroyed.
+     */
+    onSessionDestroy(): void;
+    /**
+     * Called when the xr module is destroyed.
+     */
+    onDestroy(): void;
+    constructor(_engine: Engine);
+}

package/types/xr/feature/XRFeatureType.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Enum for XR feature type.
+ */
+export declare enum XRFeatureType {
+    /** Movement tracking */
+    MovementTracking = 0,
+    /** Control camera parameters such as focal length, etc.*/
+    CameraDevice = 1,
+    /** Anchor tracking */
+    AnchorTracking = 2,
+    /** Image tracking */
+    ImageTracking = 3,
+    /** Plane tracking */
+    PlaneTracking = 4,
+    /** Hit test */
+    HitTest = 5
+}

package/types/xr/feature/XRPlatformFeature.d.ts

@@ -0,0 +1,17 @@
+import { IXRPlatformFeature, IXRFeatureDescriptor } from "@galacean/engine-design";
+import { Engine } from "../../Engine";
+/**
+ * The base class of XR platform feature.
+ */
+export declare abstract class XRPlatformFeature implements IXRPlatformFeature {
+    protected _engine: Engine;
+    constructor(engine: Engine);
+    _isSupported(descriptor: IXRFeatureDescriptor): Promise<void>;
+    _initialize(descriptor?: IXRFeatureDescriptor): Promise<void>;
+    _onUpdate(): void;
+    _onDestroy(): void;
+    _onSessionInit(): void;
+    _onSessionStart(): void;
+    _onSessionStop(): void;
+    _onSessionDestroy(): void;
+}

package/types/xr/index.d.ts

@@ -1,18 +1,16 @@
-export { XRManager, registerFeature } from "./XRManager";
-export { EnumXRMode } from "./enum/EnumXRMode";
-export { EnumXRButton } from "./enum/EnumXRButton";
-export { EnumXRFeature } from "./enum/EnumXRFeature";
-export { EnumXRSubsystem } from "./enum/EnumXRSubsystem";
-export { EnumXRDevicePhase } from "./enum/EnumXRDevicePhase";
-export { EnumXRInputSource } from "./enum/EnumXRInputSource";
-export { EnumXRTrackingMode } from "./enum/EnumXRTrackingMode";
-export { XRInputManager } from "./feature/XRInputManager";
-export { XRCameraManager } from "./feature/XRCameraManager";
-export { XRImageTrackManager } from "./feature/XRImageTrackManager";
-export { XRSubsystem } from "./subsystem/XRSubsystem";
-export { XRInputSubsystem } from "./subsystem/XRInputSubsystem";
-export { XRProvider } from "./provider/XRProvider";
-export { XRPoseDriver } from "./component/XRPoseDriver";
-export { XRDevice } from "./data/XRDevice";
-export { XRCamera } from "./data/XRCamera";
-export { XRHandle } from "./data/XRHandle";
+export { XRManager, registerXRFeatureManager } from "./XRManager";
+export type { IXRDevice } from "./IXRDevice";
+export { XRPlatformFeature } from "./feature/XRPlatformFeature";
+export { XRFeatureType } from "./feature/XRFeatureType";
+export { XRFeatureManager } from "./feature/XRFeatureManager";
+export { XRTrackingState } from "./input/XRTrackingState";
+export { XRInputManager } from "./input/XRInputManager";
+export { XRInputButton } from "./input/XRInputButton";
+export { XRInputEvent } from "./input/XRInputEvent";
+export { XRController } from "./input/XRController";
+export { XRInputType } from "./input/XRInputType";
+export { XRCamera } from "./input/XRCamera";
+export { XRTrackedUpdateFlag } from "./input/XRTrackedUpdateFlag";
+export { XRSessionManager } from "./session/XRSessionManager";
+export { XRSessionType } from "./session/XRSessionType";
+export { XRSessionState } from "./session/XRSessionState";

package/types/xr/input/XRCamera.d.ts

@@ -0,0 +1,28 @@
+import { Matrix, Rect } from "@galacean/engine-math";
+import { Camera } from "../../Camera";
+import { IXRInput, IXRPose } from "@galacean/engine-design";
+import { XRInputType } from "./XRInputType";
+import { XRTrackingState } from "./XRTrackingState";
+/**
+ * The XR camera.
+ */
+export declare class XRCamera implements IXRInput {
+    type: XRInputType;
+    /** The update frame count of xr input. */
+    frameCount: number;
+    /** The tracking state of xr input. */
+    trackingState: XRTrackingState;
+    /** The viewport of the camera. */
+    viewport: Rect;
+    /** The projection matrix of the camera. */
+    projectionMatrix: Matrix;
+    /** The associated virtual camera. */
+    camera: Camera;
+    /** The pose of the input. */
+    protected _pose: IXRPose;
+    /**
+     * Return the pose of the input.
+     */
+    get pose(): IXRPose;
+    constructor(type: XRInputType);
+}

package/types/xr/input/XRController.d.ts

@@ -0,0 +1,38 @@
+import { XRControllerPoseMode } from "./XRControllerPoseMode";
+import { DisorderedArray } from "../../DisorderedArray";
+import { IXRInput, IXRPose } from "@galacean/engine-design";
+import { XRInputButton } from "./XRInputButton";
+import { XRInputType } from "./XRInputType";
+import { XRTrackingState } from "./XRTrackingState";
+/**
+ * The XR controller.
+ */
+export declare class XRController implements IXRInput {
+    type: XRInputType;
+    /** The update frame count of xr input. */
+    frameCount: number;
+    /** The tracking state of xr input. */
+    trackingState: XRTrackingState;
+    /** The currently pressed buttons of this controller. */
+    pressedButtons: XRInputButton;
+    /** Record button lifted. */
+    upMap: number[];
+    /** Record button pressed. */
+    downMap: number[];
+    /** Record button lifted in the current frame. */
+    upList: DisorderedArray<XRInputButton>;
+    /** Record button pressed in the current frame. */
+    downList: DisorderedArray<XRInputButton>;
+    /** the pose mode of the controller. (Default is Grip) */
+    poseMode: XRControllerPoseMode;
+    /** The grip space pose of the controller. */
+    gripPose: IXRPose;
+    /** The target ray space pose of the controller. */
+    targetRayPose: IXRPose;
+    protected _pose: IXRPose;
+    /**
+     * Returns the pose of the controller.
+     */
+    get pose(): IXRPose;
+    constructor(type: XRInputType);
+}

package/types/xr/input/XRControllerPoseMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The mode of the XRControllerPose component.
+ */
+export declare enum XRControllerPoseMode {
+    /** Grip mode. */
+    Grip = 0,
+    /** Target ray mode. */
+    TargetRay = 1
+}

package/types/xr/input/XRInputButton.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Enum for XR input button.
+ */
+export declare enum XRInputButton {
+    /** None */
+    None = 0,
+    /** Select */
+    Select = 1,
+    /** Select */
+    Trigger = 1,
+    /** Squeeze */
+    Squeeze = 2,
+    /** TouchPad */
+    TouchPad = 4,
+    /** A */
+    AButton = 8,
+    /** B */
+    BButton = 16
+}

package/types/xr/input/XRInputEvent.d.ts

@@ -0,0 +1,21 @@
+import { XRInputType } from "./XRInputType";
+/**
+ * XR interaction events.
+ */
+export declare class XRInputEvent {
+    /**
+     *  TargetRayMode indicates the method by which the target ray for
+     *  the input source should be generated and how it should be presented to the user.
+     */
+    targetRayMode: "gaze" | "tracked-pointer" | "screen";
+    /** The type of input event. */
+    type: "select" | "selectend" | "selectstart" | "squeeze" | "squeezeend" | "squeezestart";
+    /** The type of input. */
+    input: XRInputType;
+    /** The unique ID of the touch point. (Appears only when targetRayMode is screen.)*/
+    id?: number;
+    /** The coordinate x on the screen. (Appears only when targetRayMode is screen.)*/
+    x?: number;
+    /** The coordinate y on the screen. (Appears only when targetRayMode is screen.) */
+    y?: number;
+}

package/types/xr/input/XRInputManager.d.ts

@@ -0,0 +1,58 @@
+import { IXRInput, IXRSession } from "@galacean/engine-design";
+import { Engine } from "../../Engine";
+import { XRController } from "./XRController";
+import { XRInputType } from "./XRInputType";
+import { UpdateFlagManager } from "../../UpdateFlagManager";
+import { XRTrackingState } from "./XRTrackingState";
+import { XRTrackedUpdateFlag } from "./XRTrackedUpdateFlag";
+/**
+ * The manager of XR input.
+ */
+export declare class XRInputManager {
+    protected _engine: Engine;
+    protected _session: IXRSession;
+    protected _inputs: IXRInput[];
+    protected _controllers: XRController[];
+    protected _added: IXRInput[];
+    protected _updated: IXRInput[];
+    protected _removed: IXRInput[];
+    protected _statusSnapshot: XRTrackingState[];
+    protected _trackingUpdate: UpdateFlagManager;
+    /**
+     * Returns the input instance.
+     * @param type - The input type
+     * @returns The input instance
+     */
+    getInput<T extends IXRInput>(type: XRInputType): T;
+    /**
+     * Add a listener to the input update event.
+     * @param listener - The listener to add
+     */
+    addListener(listener: (type: XRTrackedUpdateFlag, param: readonly IXRInput[]) => any): void;
+    /**
+     * Remove a listener from the input update event.
+     * @param listener - The listener to remove
+     */
+    removeListener(listener: (type: XRTrackedUpdateFlag, param: readonly IXRInput[]) => any): void;
+    /**
+     * Returns whether the button is pressed.
+     * @param button - The button to check
+     * @returns Whether the button is pressed
+     */
+    isButtonDown(button: number, out: XRController[]): XRController[];
+    /**
+     * Returns whether the button is lifted.
+     * @param button - The button to check
+     * @returns Whether the button is lifted
+     */
+    isButtonUp(button: number, out: XRController[]): XRController[];
+    /**
+     * Returns whether the button is held down.
+     * @param button - The button to check
+     * @returns Whether the button is held down
+     */
+    isButtonHeldDown(button: number, out: XRController[]): XRController[];
+    constructor(engine: Engine);
+    private _handleEvent;
+    private _makeUpPointerEvent;
+}

package/types/xr/input/XRInputType.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Enum for XR input type.
+ */
+export declare enum XRInputType {
+    /** Controller */
+    Controller = 0,
+    /** Left controller */
+    LeftController = 1,
+    /** Right controller */
+    RightController = 2,
+    /** Camera */
+    Camera = 3,
+    /** Left camera */
+    LeftCamera = 4,
+    /** Right camera */
+    RightCamera = 5,
+    /** Head */
+    LeftHand = 6,
+    /** Right hand */
+    RightHand = 7,
+    /** Length of input type */
+    Length = 8
+}

package/types/xr/input/XRTrackedUpdateFlag.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Enum for XR tracked update flag.
+ */
+export declare enum XRTrackedUpdateFlag {
+    /** The object that was not tracked in the previous frame was tracked in this frame. */
+    Added = 0,
+    /** Both the previous frame and this frame are tracked */
+    Updated = 1,
+    /** The object that was tracked in the previous frame is not tracked in this frame. */
+    Removed = 2
+}