@galacean/engine-core 1.2.0-alpha.0 → 1.2.0-alpha.2

package/types/xr/feature/trackable/anchor/XRAnchorTracking.d.ts

@@ -0,0 +1,37 @@
+import { Quaternion, Vector3 } from "@galacean/engine-math";
+import { XRManager } from "../../../XRManager";
+import { XRTrackableFeature } from "../XRTrackableFeature";
+import { XRAnchor } from "./XRAnchor";
+import { XRRequestAnchor } from "./XRRequestAnchor";
+/**
+ * The manager of XR anchor tracking.
+ */
+export declare class XRAnchorTracking extends XRTrackableFeature<XRAnchor, XRRequestAnchor> {
+    private _anchors;
+    /**
+     * The anchors to tracking.
+     */
+    get trackingAnchors(): readonly XRAnchor[];
+    /**
+     * The tracked anchors.
+     */
+    get trackedAnchors(): readonly XRAnchor[];
+    /**
+     * @param xrManager - The xr manager
+     */
+    constructor(xrManager: XRManager);
+    /**
+     * Add a anchor in XR space.
+     * @param anchor - The anchor to be added
+     */
+    addAnchor(position: Vector3, rotation: Quaternion): XRAnchor;
+    /**
+     * Remove a anchor in XR space.
+     * @param anchor - The anchor to be removed
+     */
+    removeAnchor(anchor: XRAnchor): void;
+    /**
+     * Remove all tracking anchors.
+     */
+    clearAnchors(): void;
+}

package/types/xr/feature/trackable/anchor/XRAnchorTrackingManager.d.ts

@@ -0,0 +1,20 @@
+import { IXRPose, IXRTracked, IXRAnchorTracking, IXRRequestAnchorTracking, IXRAnchorTrackingDescriptor } from "@galacean/engine-design";
+import { XRTrackableManager } from "../XRTrackableManager";
+export declare class XRAnchorTrackingManager extends XRTrackableManager<IXRAnchorTrackingDescriptor, IXRTracked, IXRRequestAnchorTracking, IXRAnchorTracking> {
+    /**
+     * Add a tracking anchor.
+     * @param pose - The pose of anchor to be added
+     */
+    addAnchor(pose: IXRPose): IXRRequestAnchorTracking;
+    /**
+     * Remove a tracking anchor.
+     * @param anchor - The anchor to be removed
+     */
+    removeAnchor(anchor: IXRRequestAnchorTracking): void;
+    /**
+     * Remove all tracking anchors.
+     */
+    removeAllAnchors(): void;
+    initialize(): Promise<void>;
+    private _createRequestTracking;
+}

package/types/xr/feature/trackable/anchor/XRRequestAnchor.d.ts

@@ -0,0 +1,15 @@
+import { Quaternion, Vector3 } from "@galacean/engine-math";
+import { XRRequestTracking } from "../XRRequestTracking";
+import { XRAnchor } from "./XRAnchor";
+/**
+ * The request anchor in XR space.
+ */
+export declare class XRRequestAnchor extends XRRequestTracking<XRAnchor> {
+    position: Vector3;
+    rotation: Quaternion;
+    /**
+     * @param position - Requests the position of the anchor to be added
+     * @param rotation - Requests the rotation of the anchor to be added
+     */
+    constructor(position: Vector3, rotation: Quaternion);
+}

package/types/xr/feature/trackable/image/XRImageTracking.d.ts

@@ -0,0 +1,24 @@
+import { XRManager } from "../../../XRManager";
+import { XRTrackableFeature } from "../XRTrackableFeature";
+import { XRReferenceImage } from "./XRReferenceImage";
+import { XRRequestImage } from "./XRRequestImage";
+import { XRTrackedImage } from "./XRTrackedImage";
+/**
+ * The manager of XR image tracking.
+ */
+export declare class XRImageTracking extends XRTrackableFeature<XRTrackedImage, XRRequestImage> {
+    private _images;
+    /**
+     * The image to tracking.
+     */
+    get images(): readonly XRReferenceImage[];
+    /**
+     * The tracked images.
+     */
+    get trackedImages(): readonly XRTrackedImage[];
+    /**
+     * @param xrManager - The xr manager
+     * @param images - The images to be tracked
+     */
+    constructor(xrManager: XRManager, images: XRReferenceImage[]);
+}

package/types/xr/feature/trackable/image/XRImageTrackingManager.d.ts

@@ -0,0 +1,31 @@
+import { IXRImageTracking, IXRRequestImageTracking, IXRTrackedImage, IXRImageTrackingDescriptor } from "@galacean/engine-design";
+import { XRTrackableManager } from "../XRTrackableManager";
+import { XRReferenceImage } from "./XRReferenceImage";
+export declare class XRImageTrackingManager extends XRTrackableManager<IXRImageTrackingDescriptor, IXRTrackedImage, IXRRequestImageTracking, IXRImageTracking> {
+    /**
+     * Add a tracking image
+     * @param image - xr reference image
+     */
+    addImage(image: XRReferenceImage): void;
+    /**
+     * Add tracking images
+     * @param images - xr reference images
+     */
+    addImage(images: XRReferenceImage[]): void;
+    /**
+     * Remove a tracking image
+     * @param image - xr reference image
+     */
+    removeImage(image: XRReferenceImage): void;
+    /**
+     * Remove tracking images
+     * @param images - xr reference images
+     */
+    removeImage(images: XRReferenceImage[]): void;
+    /**
+     * Remove all tracking images
+     */
+    removeAllImages(): void;
+    initialize(): Promise<void>;
+    private _createRequestTracking;
+}

package/types/xr/feature/trackable/image/XRReferenceImage.d.ts

@@ -0,0 +1,11 @@
+import { IXRReferenceImage } from "@galacean/engine-design";
+/**
+ *  A reference image is an image to look for in the physical environment.
+ */
+export declare class XRReferenceImage implements IXRReferenceImage {
+    name: string;
+    src: string | HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | Blob | ImageData | ImageBitmap | OffscreenCanvas;
+    physicalWidth: number;
+    physicalHeight: number;
+    constructor(name: string, src: string | HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | Blob | ImageData | ImageBitmap | OffscreenCanvas, physicalWidth?: number, physicalHeight?: number);
+}

package/types/xr/feature/trackable/image/XRRequestImage.d.ts

@@ -0,0 +1,13 @@
+import { XRRequestTracking } from "../XRRequestTracking";
+import { XRReferenceImage } from "./XRReferenceImage";
+import { XRTrackedImage } from "./XRTrackedImage";
+/**
+ * The request image in XR space.
+ */
+export declare class XRRequestImage extends XRRequestTracking<XRTrackedImage> {
+    image: XRReferenceImage;
+    /**
+     * @param image - The image to be tracked
+     */
+    constructor(image: XRReferenceImage);
+}

package/types/xr/feature/trackable/image/XRTrackedImage.d.ts

@@ -0,0 +1,8 @@
+import { XRTracked } from "../XRTracked";
+/**
+ * A tracked image in XR space.
+ */
+export declare class XRTrackedImage extends XRTracked {
+    /** The width of the image in meters in the physical world. */
+    measuredWidthInMeters: number;
+}

package/types/xr/feature/trackable/plane/XRPlaneMode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Enumerates modes of plane in XR.
+ */
+export declare enum XRPlaneMode {
+    /** None. */
+    None = 0,
+    /** Horizontal */
+    Horizontal = 1,
+    /** Vertical */
+    Vertical = 2,
+    /** Includes horizontal and vertical. */
+    EveryThing = 3
+}

package/types/xr/feature/trackable/plane/XRPlaneTracking.d.ts

@@ -0,0 +1,23 @@
+import { XRManager } from "../../../XRManager";
+import { XRTrackableFeature } from "../XRTrackableFeature";
+import { XRPlaneMode } from "./XRPlaneMode";
+import { XRRequestPlane } from "./XRRequestPlane";
+import { XRTrackedPlane } from "./XRTrackedPlane";
+/**
+ * The manager of plane tracking feature.
+ */
+export declare class XRPlaneTracking extends XRTrackableFeature<XRTrackedPlane, XRRequestPlane> {
+    /**
+     * The plane detection mode.
+     */
+    get detectionMode(): XRPlaneMode;
+    /**
+     * The tracked planes.
+     */
+    get trackedPlanes(): readonly XRTrackedPlane[];
+    /**
+     * @param xrManager - The xr manager
+     * @param detectionMode - The plane detection mode
+     */
+    constructor(xrManager: XRManager, detectionMode?: XRPlaneMode);
+}

package/types/xr/feature/trackable/plane/XRPlaneTrackingManager.d.ts

@@ -0,0 +1,11 @@
+import { IXRPlaneTracking, IXRPlaneTrackingDescriptor, IXRRequestPlaneTracking, IXRTrackedPlane } from "@galacean/engine-design";
+import { XRPlaneMode } from "./XRPlaneMode";
+import { XRTrackableManager } from "../XRTrackableManager";
+export declare class XRPlaneTrackingManager extends XRTrackableManager<IXRPlaneTrackingDescriptor, IXRTrackedPlane, IXRRequestPlaneTracking, IXRPlaneTracking> {
+    /**
+     * Return the plane detection mode for XR.
+     */
+    get detectionMode(): XRPlaneMode;
+    set detectionMode(value: XRPlaneMode);
+    initialize(): Promise<void>;
+}

package/types/xr/feature/trackable/plane/XRRequestPlane.d.ts

@@ -0,0 +1,12 @@
+import { XRRequestTracking } from "../XRRequestTracking";
+import { XRTrackedPlane } from "./XRTrackedPlane";
+/**
+ * The request plane in XR space.
+ */
+export declare class XRRequestPlane extends XRRequestTracking<XRTrackedPlane> {
+    detectionMode: number;
+    /**
+     * @param detectionMode - The plane detection mode
+     */
+    constructor(detectionMode: number);
+}

package/types/xr/feature/trackable/plane/XRTrackedPlane.d.ts

@@ -0,0 +1,20 @@
+import { Vector3 } from "@galacean/engine-math";
+import { XRTracked } from "../XRTracked";
+import { XRPlaneMode } from "./XRPlaneMode";
+/**
+ * The tracked plane in XR space.
+ */
+export declare class XRTrackedPlane extends XRTracked {
+    /** Whether the detected plane is horizontal or vertical. */
+    planeMode: XRPlaneMode;
+    /** The points that make up this plane.
+     *  Note: These points are in the plane coordinate system,
+     *  and their Y coordinates are all zero.
+     */
+    polygon: Vector3[];
+    /**
+     * Whether this frame changes the attributes of the plane.
+     * Note: Includes `polygon` but no `pose`.
+     */
+    attributesDirty: boolean;
+}

package/types/xr/index.d.ts

@@ -0,0 +1,25 @@
+export { XRManager, YRManager } from "./XRManager";
+export { XRPose } from "./XRPose";
+export { XRFeature } from "./feature/XRFeature";
+export { XRFeatureType } from "./feature/XRFeatureType";
+export { XRCameraManager } from "./feature/camera/XRCameraManager";
+export { TrackableType } from "./feature/hitTest/TrackableType";
+export { XRHitResult } from "./feature/hitTest/XRHitResult";
+export { XRHitTest } from "./feature/hitTest/XRHitTest";
+export { XRRequestTrackingState } from "./feature/trackable/XRRequestTrackingState";
+export { XRAnchorTracking } from "./feature/trackable/anchor/XRAnchorTracking";
+export { XRImageTracking } from "./feature/trackable/image/XRImageTracking";
+export { XRReferenceImage } from "./feature/trackable/image/XRReferenceImage";
+export { XRPlaneMode } from "./feature/trackable/plane/XRPlaneMode";
+export { XRPlaneTracking } from "./feature/trackable/plane/XRPlaneTracking";
+export { XRCamera } from "./input/XRCamera";
+export { XRController } from "./input/XRController";
+export { XRInputButton } from "./input/XRInputButton";
+export { XRInputEventType } from "./input/XRInputEventType";
+export { XRInputManager } from "./input/XRInputManager";
+export { XRTargetRayMode } from "./input/XRTargetRayMode";
+export { XRTrackedInputDevice } from "./input/XRTrackedInputDevice";
+export { XRTrackingState } from "./input/XRTrackingState";
+export { XRSessionManager } from "./session/XRSessionManager";
+export { XRSessionMode } from "./session/XRSessionMode";
+export { XRSessionState } from "./session/XRSessionState";

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

@@ -0,0 +1,15 @@
+import { IXRCamera } from "@galacean/engine-design";
+import { Matrix, Rect } from "@galacean/engine-math";
+import { XRPose } from "../XRPose";
+import { XRInput } from "./XRInput";
+/**
+ * The XR camera.
+ */
+export declare class XRCamera extends XRInput implements IXRCamera {
+    /** The pose of the camera in XR space. */
+    pose: XRPose;
+    /** The viewport of the camera. */
+    viewport: Rect;
+    /** The projection matrix of the camera. */
+    projectionMatrix: Matrix;
+}

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

@@ -0,0 +1,38 @@
+import { IXRController } from "@galacean/engine-design";
+import { XRPose } from "../XRPose";
+import { XRInput } from "./XRInput";
+import { XRInputButton } from "./XRInputButton";
+/**
+ * The XR controller.
+ */
+export declare class XRController extends XRInput implements IXRController {
+    /** The grip space pose of the controller in XR space. */
+    gripPose: XRPose;
+    /** The target ray space pose of the controller in XR space. */
+    targetRayPose: XRPose;
+    /** The currently pressed buttons of this controller. */
+    pressedButtons: XRInputButton;
+    /** Record button lifted. */
+    down: XRInputButton;
+    /** Record button pressed. */
+    up: XRInputButton;
+    /**
+     *
+     * Returns whether the button is pressed.
+     * @param button - The button to check
+     * @returns Whether the button is pressed
+     */
+    isButtonDown(button: XRInputButton): boolean;
+    /**
+     * Returns whether the button is lifted.
+     * @param button - The button to check
+     * @returns Whether the button is lifted
+     */
+    isButtonUp(button: XRInputButton): boolean;
+    /**
+     * Returns whether the button is held down.
+     * @param button - The button to check
+     * @returns Whether the button is held down
+     */
+    isButtonHeldDown(button: XRInputButton): boolean;
+}

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/XRInput.d.ts

@@ -0,0 +1,8 @@
+import { IXRInput } from "@galacean/engine-design";
+import { XRTrackedInputDevice } from "./XRTrackedInputDevice";
+import { XRTrackingState } from "./XRTrackingState";
+export declare class XRInput implements IXRInput {
+    type: XRTrackedInputDevice;
+    /** The tracking state of xr input. */
+    trackingState: XRTrackingState;
+}

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,24 @@
+import { IXRInputEvent } from "@galacean/engine-design";
+import { XRInputEventType } from "./XRInputEventType";
+import { XRTargetRayMode } from "./XRTargetRayMode";
+import { XRTrackedInputDevice } from "./XRTrackedInputDevice";
+/**
+ * XR interaction events.
+ */
+export declare class XRInputEvent implements IXRInputEvent {
+    /**
+     *  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: XRTargetRayMode;
+    /** The type of input event. */
+    type: XRInputEventType;
+    /** The type of input. */
+    input: XRTrackedInputDevice;
+    /** 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/XRInputEventType.d.ts

@@ -0,0 +1,11 @@
+/**
+ *  The type of input event.
+ */
+export declare enum XRInputEventType {
+    SelectStart = 0,
+    Select = 1,
+    SelectEnd = 2,
+    SqueezeStart = 3,
+    Squeeze = 4,
+    SqueezeEnd = 5
+}

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

@@ -0,0 +1,31 @@
+import { XRInput } from "./XRInput";
+import { XRTrackedInputDevice } from "./XRTrackedInputDevice";
+/**
+ * The manager of XR input.
+ */
+export declare class XRInputManager {
+    private _engine;
+    private _added;
+    private _removed;
+    private _trackedDevices;
+    private _statusSnapshot;
+    private _listeners;
+    /**
+     * Returns the tracked device instance.
+     * @param type - The tracked input device type
+     * @returns The input instance
+     */
+    getTrackedDevice<T extends XRInput>(type: XRTrackedInputDevice): T;
+    /**
+     * Add a listener for tracked device changes.
+     * @param listener - The listener to add
+     */
+    addTrackedDeviceChangedListener(listener: (added: readonly XRInput[], removed: readonly XRInput[]) => void): void;
+    /**
+     * Remove a listener of tracked device changes.
+     * @param listener - The listener to remove
+     */
+    removeTrackedDeviceChangedListener(listener: (added: readonly XRInput[], removed: readonly XRInput[]) => void): void;
+    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/XRTargetRayMode.d.ts

@@ -0,0 +1,12 @@
+/**
+ *  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.
+ */
+export declare enum XRTargetRayMode {
+    /** Eye */
+    Gaze = 0,
+    /** Controller */
+    TrackedPointer = 1,
+    /** Game pad */
+    Screen = 2
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Enumerates some input devices that can be tracked.(including status, posture and other information)
+ */
+export declare enum XRTrackedInputDevice {
+    /** 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
+}

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
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Enum for XR tracking state.
+ */
+export declare enum XRTrackingState {
+    /** Not tracking */
+    NotTracking = 0,
+    /** Tracking */
+    Tracking = 1,
+    /** Lost track */
+    TrackingLost = 2
+}

package/types/xr/session/XRSessionManager.d.ts

@@ -0,0 +1,45 @@
+import { Engine } from "../../Engine";
+import { XRSessionMode } from "./XRSessionMode";
+import { XRSessionState } from "./XRSessionState";
+/**
+ * XRSessionManager manages the life cycle of XR sessions.
+ */
+export declare class XRSessionManager {
+    protected _engine: Engine;
+    private _mode;
+    private _state;
+    private _rhi;
+    private _raf;
+    private _caf;
+    /**
+     * The current session mode( AR or VR ).
+     */
+    get mode(): XRSessionMode;
+    /**
+     * Return the current session state.
+     */
+    get state(): XRSessionState;
+    /**
+     * Return a list of supported frame rates.(only available in-session)
+     */
+    get supportedFrameRate(): Float32Array;
+    /**
+     * Return the current frame rate as reported by the device.
+     */
+    get frameRate(): number;
+    /**
+     * 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
+     */
+    isSupportedMode(mode: XRSessionMode): Promise<void>;
+    /**
+     * Run the session.
+     */
+    run(): void;
+    /**
+     * Stop the session.
+     */
+    stop(): void;
+    private _onSessionExit;
+}

package/types/xr/session/XRSessionMode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The type of XR session.
+ */
+export declare enum XRSessionMode {
+    None = 0,
+    AR = 1,
+    VR = 2
+}

package/types/xr/session/XRSessionState.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The state of an XRSession.
+ */
+export declare enum XRSessionState {
+    /** Not initialized. */
+    None = 0,
+    /** Initialized but not started. */
+    Initialized = 1,
+    /** Running. */
+    Running = 2,
+    /** Paused. */
+    Paused = 3
+}

package/types/RenderPipeline/MeshRenderElement.d.ts

@@ -1,19 +0,0 @@
-import { Mesh } from "../graphic/Mesh";
-import { SubMesh } from "../graphic/SubMesh";
-import { Material } from "../material/Material";
-import { Renderer } from "../Renderer";
-import { ShaderPass } from "../shader/ShaderPass";
-import { RenderState } from "../shader/state/RenderState";
-import { IPoolElement } from "./IPoolElement";
-import { RenderElement } from "./RenderElement";
-/**
- * Render element.
- */
-export declare class MeshRenderElement extends RenderElement implements IPoolElement {
-    /** Mesh. */
-    mesh: Mesh;
-    /** Sub mesh. */
-    subMesh: SubMesh;
-    setValue(component: Renderer, mesh: Mesh, subMesh: SubMesh, material: Material, renderState: RenderState, shaderPass: ShaderPass): void;
-    dispose(): void;
-}

package/types/RenderPipeline/SpriteElement.d.ts

@@ -1,15 +0,0 @@
-import { RenderData2D } from "../2d/data/RenderData2D";
-import { Material } from "../material/Material";
-import { Renderer } from "../Renderer";
-import { ShaderPass } from "../shader";
-import { RenderState } from "../shader/state/RenderState";
-import { Texture2D } from "../texture";
-import { IPoolElement } from "./IPoolElement";
-import { RenderElement } from "./RenderElement";
-export declare class SpriteElement extends RenderElement implements IPoolElement {
-    renderData: RenderData2D;
-    texture: Texture2D;
-    constructor();
-    setValue(component: Renderer, renderDate: RenderData2D, material: Material, texture: Texture2D, renderState: RenderState, shaderPass: ShaderPass): void;
-    dispose(): void;
-}

package/types/RenderPipeline/SpriteMaskElement.d.ts

@@ -1,12 +0,0 @@
-import { RenderData2D } from "../2d/data/RenderData2D";
-import { Material } from "../material/Material";
-import { Renderer } from "../Renderer";
-import { IPoolElement } from "./IPoolElement";
-import { RenderElement } from "./RenderElement";
-export declare class SpriteMaskElement extends RenderElement implements IPoolElement {
-    renderData: RenderData2D;
-    isAdd: boolean;
-    constructor();
-    setValue(component: Renderer, renderData: RenderData2D, material: Material): void;
-    dispose(): void;
-}