@galacean/engine-core 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-core",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
@@ -15,10 +15,10 @@
     "types/**/*"
   ],
   "dependencies": {
-    "@galacean/engine-math": "1.0.3"
+    "@galacean/engine-math": "1.0.5"
   },
   "devDependencies": {
-    "@galacean/engine-design": "1.0.3"
+    "@galacean/engine-design": "1.0.5"
   },
   "scripts": {
     "b:types": "tsc"

package/types/animation/AnimatorLayerMask.d.ts

@@ -0,0 +1,45 @@
+import { Entity } from "../Entity";
+import { LayerPathMask } from "./LayerPathMask";
+/**
+ * AnimatorLayerMask is used to mask out certain entities from being animated by an AnimatorLayer.
+ */
+export declare class AnimatorLayerMask {
+    /**
+     * Creates an AnimatorLayerMask instance by specifying an entity.
+     * This will automatically add path masks for the entity and all its children.
+     * @param entity - The root entity to create path masks for
+     */
+    static createByEntity(entity: Entity): AnimatorLayerMask;
+    private static _addPathMaskWithChildren;
+    private _pathMasks;
+    private _pathMaskMap;
+    /**
+     * The list of path masks.
+     */
+    get pathMasks(): Readonly<LayerPathMask[]>;
+    /**
+     * Adds a path mask to the AnimatorLayerMask, the root path is "".
+     * @param path - The path to add a mask for
+     * @returns The created or existing LayerPathMask
+     */
+    addPathMask(path: string): LayerPathMask;
+    /**
+     * Removes a path mask from the AnimatorLayerMask.
+     * @param path - The path of the mask to remove
+     */
+    removePathMask(path: any): void;
+    /**
+     * Get a path mask based on the given path.
+     * @param path - The path of the mask to get
+     * @returns The LayerPathMask for the given path
+     */
+    getPathMask(path: string): LayerPathMask;
+    /**
+     * Sets the active state of a path mask.
+     * If recursive is true, it also sets the active state of all child path masks.
+     * @param path - The path of the mask to modify
+     * @param active - The active state to set
+     * @param withChildren - Whether to apply the active state recursively to child paths
+     */
+    setPathMaskActive(path: string, active: boolean, withChildren?: boolean): void;
+}

package/types/animation/LayerPathMask.d.ts

@@ -0,0 +1,16 @@
+/**
+ * LayerPathMask represents a mask for a specific entity in an animation layer.
+ * It is used to control the animation whether to be applied to the entity or not.
+ */
+export declare class LayerPathMask {
+    /**
+     * It identifies a particular entity in the hierarchy.
+     * Example: "arm/left/hand" could be a path to the left hand of a character.
+     */
+    path: string;
+    /**
+     * The active property is indicating whether the animation at this path is active or not.
+     * When true, the animation for this path is applied; when false, the animation for this path is ignored.
+     */
+    active: boolean;
+}

package/types/animation/animationCurve/AnimationStringCurve.d.ts

@@ -0,0 +1,7 @@
+import { AnimationCurve } from "./AnimationCurve";
+/**
+ * Store a collection of Keyframes that can be evaluated over time.
+ */
+export declare class AnimationStringCurve extends AnimationCurve<string> {
+    constructor();
+}

package/types/particle/ParticleGenerator.d.ts

@@ -1,4 +1,3 @@
-import { ParticleRenderer } from "./ParticleRenderer";
 import { ParticleStopMode } from "./enums/ParticleStopMode";
 import { ColorOverLifetimeModule } from "./modules/ColorOverLifetimeModule";
 import { EmissionModule } from "./modules/EmissionModule";
@@ -47,7 +46,6 @@ export declare class ParticleGenerator {
      */
     get randomSeed(): number;
     set randomSeed(value: number);
-    constructor(renderer: ParticleRenderer);
     /**
      * Start emitting particles.
      * @param withChildren - Whether to start the particle generator of the child entity

package/types/particle/modules/EmissionModule.d.ts

@@ -13,7 +13,6 @@ export declare class EmissionModule extends ParticleGeneratorModule {
     /** The shape of the emitter. */
     shape: BaseShape;
     private _bursts;
-    private _frameRateTime;
     private _currentBurstIndex;
     private _burstRand;
     /**

package/types/particle/modules/MainModule.d.ts

@@ -54,7 +54,6 @@ export declare class MainModule implements ICustomClone {
     scalingMode: ParticleScaleMode;
     /** If set to true, the Particle Generator automatically begins to play on startup. */
     playOnEnabled: boolean;
-    private _maxParticles;
     private _generator;
     private _gravity;
     /**

package/types/particle/modules/ParticleGeneratorModule.d.ts

@@ -7,6 +7,5 @@ export declare abstract class ParticleGeneratorModule {
     /** Specifies whether the module is enabled or not. */
     enabled: boolean;
     protected _generator: ParticleGenerator;
-    constructor(generator: ParticleGenerator);
     protected _enableMacro(shaderData: ShaderData, lastEnableMacro: ShaderMacro, enableMacro: ShaderMacro): ShaderMacro;
 }

package/types/particle/modules/ParticleGradient.d.ts

@@ -63,32 +63,52 @@ export declare class ParticleGradient {
     setKeys(colorKeys: GradientColorKey[], alphaKeys: GradientAlphaKey[]): void;
     private _addKey;
     private _removeKey;
+    private _setColorTypeArrayDirty;
+    private _setAlphaTypeArrayDirty;
 }
 /**
  * The color key of the particle gradient.
  */
 export declare class GradientColorKey {
-    /** The key time. */
-    time: number;
-    /** The key color. */
-    color: Color;
-    constructor(
-    /** The key time. */
-    time: number, 
-    /** The key color. */
-    color: Color);
+    private _time;
+    private _color;
+    /**
+     * The key time.
+     */
+    get time(): number;
+    set time(value: number);
+    /**
+     * The key color.
+     */
+    get color(): Color;
+    set color(value: Color);
+    /**
+     * Constructor of GradientColorKey.
+     * @param time - The time of the gradient colorKey
+     * @param color - The alpha component of the gradient colorKey
+     */
+    constructor(time: number, color: Color);
 }
 /**
  * The alpha key of the particle gradient.
  */
 export declare class GradientAlphaKey {
-    /** The key time. */
-    time: number;
-    /** The key alpha. */
-    alpha: number;
-    constructor(
-    /** The key time. */
-    time: number, 
-    /** The key alpha. */
-    alpha: number);
+    private _time;
+    private _alpha;
+    /**
+     * The key time.
+     */
+    get time(): number;
+    set time(value: number);
+    /**
+     * The key alpha.
+     */
+    get alpha(): number;
+    set alpha(value: number);
+    /**
+     * Constructor of GradientAlphaKey.
+     * @param time - The time of the gradient alpha key
+     * @param alpha - The alpha component of the gradient alpha key
+     */
+    constructor(time: number, alpha: number);
 }

package/types/xr/XRManager.d.ts

@@ -1,31 +1,5 @@
-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;
+/**
+ * XRManager located in the main package, its implementation logic is XRManagerExtended in the sub-package engine-xr.
+ */
 export declare class XRManager {
-    private _engine;
-    private _provider;
-    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;
-    destroy(): void;
-    constructor(engine: Engine, type: new (engine: Engine) => XRProvider);
 }
-export declare function registerFeature(feature: EnumXRFeature, dependentSubsystem?: EnumXRSubsystem[]): (featureConstructor: FeatureConstructor) => void;
-export {};

package/types/xr/XRPose.d.ts

@@ -0,0 +1,15 @@
+import { IXRPose } from "@galacean/engine-design";
+import { Matrix, Quaternion, Vector3 } from "@galacean/engine-math";
+/**
+ * Data for describing pose in the XR space.
+ */
+export declare class XRPose implements IXRPose {
+    /** The position of the pose in XR space. */
+    position: Vector3;
+    /** The rotation of the pose in XR space. */
+    rotation: Quaternion;
+    /** The matrix of the pose in XR space. */
+    matrix: Matrix;
+    /** The inverse matrix of the pose in XR space. */
+    inverseMatrix: Matrix;
+}

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

@@ -1,29 +1,16 @@
-import { Engine } from "../../Engine";
-export declare abstract class XRFeature {
-    protected _engine: Engine;
+import { IXRPlatformFeature } from "@galacean/engine-design";
+import { XRManager } from "../XRManager";
+import { XRFeatureType } from "./XRFeatureType";
+/**
+ * The base class of XR feature manager.
+ */
+export declare abstract class XRFeature<T extends IXRPlatformFeature = IXRPlatformFeature> {
+    protected _xrManager: XRManager;
+    protected _type: XRFeatureType;
+    protected _enabled: boolean;
     /**
-     * Enable an instance of a feature.
-     * This method needs to be override.
-     * @returns
+     * Returns whether the feature is enabled.
      */
-    onEnable(): void;
-    /**
-     * Disable an instance of a feature.
-     * This method needs to be override.
-     * @returns
-     */
-    onDisable(): void;
-    /**
-     * Update an instance of a feature.
-     * This method needs to be override.
-     * @returns
-     */
-    onUpdate(): void;
-    /**
-     * Destroy an instance of a feature.
-     * This method needs to be override.
-     * @returns
-     */
-    onDestroy(): void;
-    constructor(engine: Engine);
+    get enabled(): boolean;
+    set enabled(value: boolean);
 }

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

@@ -0,0 +1,65 @@
+import { IXRFeatureDescriptor, IXRFeatureManager, IXRFeature, IXRSession, IXRFrame } from "@galacean/engine-design";
+import { Engine } from "../../Engine";
+/**
+ * The base class of XR feature manager.
+ */
+export declare abstract class XRFeatureManager<TDescriptor extends IXRFeatureDescriptor = IXRFeatureDescriptor, TFeature extends IXRFeature = IXRFeature> implements IXRFeatureManager {
+    protected _engine: Engine;
+    _platformFeature: TFeature;
+    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(session: IXRSession, frame: IXRFrame): 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,13 @@
+/**
+ * Enum for XR feature type.
+ */
+export declare enum XRFeatureType {
+    /** Anchor tracking */
+    AnchorTracking = 0,
+    /** Image tracking */
+    ImageTracking = 1,
+    /** Plane tracking */
+    PlaneTracking = 2,
+    /** Hit test */
+    HitTest = 3
+}

package/types/xr/feature/camera/XRCameraManager.d.ts

@@ -0,0 +1,26 @@
+import { Camera } from "../../../Camera";
+import { XRTrackedInputDevice } from "../../input/XRTrackedInputDevice";
+/**
+ * The manager of XR camera.
+ */
+export declare class XRCameraManager {
+    private _xrManager;
+    /**
+     * The fixed foveation of the camera.
+     */
+    get fixedFoveation(): number;
+    set fixedFoveation(value: number);
+    /**
+     * Attach the camera to the specified input type(Camera, LeftCamera or RightCamera).
+     * The camera entity need to be moved to the XROrigin entity.
+     * @param type - The input type
+     * @param camera - The camera to be attached
+     */
+    attachCamera(type: XRTrackedInputDevice.Camera | XRTrackedInputDevice.LeftCamera | XRTrackedInputDevice.RightCamera, camera: Camera): void;
+    /**
+     * Detach the camera from the specified input type.
+     * @param type - The input type
+     * @returns The camera that was detached
+     */
+    detachCamera(type: XRTrackedInputDevice.Camera | XRTrackedInputDevice.LeftCamera | XRTrackedInputDevice.RightCamera): Camera;
+}

package/types/xr/feature/hitTest/TrackableType.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Enum for the types of hit test that can be performed.
+ * Note: currently only supports plane.
+ */
+export declare enum TrackableType {
+    /** Tracked plane. */
+    Plane = 1,
+    /** All tracked objects. */
+    All = 1
+}

package/types/xr/feature/hitTest/XRHitResult.d.ts

@@ -0,0 +1,19 @@
+import { IXRTracked } from "@galacean/engine-design";
+import { Vector3 } from "@galacean/engine-math";
+import { TrackableType } from "./TrackableType";
+/**
+ * XR hit result.
+ * It is the detection result returned by using XR HitTest feature.
+ */
+export declare class XRHitResult {
+    /** The position of the hit point. */
+    point: Vector3;
+    /** The normal of the hit point. */
+    normal: Vector3;
+    /** The distance from the origin of the ray to the hit point. */
+    distance: number;
+    /** The hit tracked object, such as IXRTrackedPlane. */
+    trackedObject: IXRTracked;
+    /** The type of tracked object detected, such as TrackableType.Plane */
+    trackableType: TrackableType;
+}

package/types/xr/feature/hitTest/XRHitTest.d.ts

@@ -0,0 +1,39 @@
+import { Ray } from "@galacean/engine-math";
+import { XRManager } from "../../XRManager";
+import { XRFeature } from "../XRFeature";
+import { TrackableType } from "./TrackableType";
+import { XRHitResult } from "./XRHitResult";
+/**
+ * The manager of XR hit test.
+ */
+export declare class XRHitTest extends XRFeature {
+    private _tempRay;
+    private _tempVec2;
+    private _tempVec30;
+    private _tempVec31;
+    private _tempVec32;
+    private _tempVec33;
+    private _tempVec34;
+    private _tempVec35;
+    /**
+     * @param xrManager - The xr manager
+     */
+    constructor(xrManager: XRManager);
+    /**
+     * Hit test.
+     * @param ray - The ray to test
+     * @param type - The type of hit test
+     * @returns The hit result
+     */
+    hitTest(ray: Ray, type: TrackableType): XRHitResult[];
+    /**
+     * Screen hit test.
+     * @param x - The x coordinate of the screen point (normalized)
+     * @param y - The y coordinate of the screen point (normalized)
+     * @param type - The type of hit test
+     * @returns The hit result
+     */
+    screenHitTest(x: number, y: number, type: TrackableType): XRHitResult[];
+    private _hitTestPlane;
+    private _checkPointerWithinPlane;
+}

package/types/xr/feature/hitTest/XRHitTestManager.d.ts

@@ -0,0 +1,38 @@
+import { IXRFeatureDescriptor, IXRHitResult } from "@galacean/engine-design";
+import { XRHitTestType } from "./XRHitTestType";
+import { Ray } from "@galacean/engine-math";
+import { XRFeatureManager } from "../XRFeatureManager";
+export declare class XRHitTestManager extends XRFeatureManager {
+    private _tempRay;
+    private _tempVec2;
+    private _tempVec30;
+    private _tempVec31;
+    private _tempVec32;
+    private _tempVec33;
+    private _tempVec34;
+    private _tempVec35;
+    /**
+     * Returns whether the feature is supported.
+     * @param descriptor - The descriptor of the feature
+     * @returns The promise of the feature
+     */
+    isSupported(descriptor?: IXRFeatureDescriptor): Promise<void>;
+    /**
+     * Hit test.
+     * @param ray - The ray to test
+     * @param type - The type of hit test
+     * @returns The hit result
+     */
+    hitTest(ray: Ray, type: XRHitTestType): IXRHitResult[];
+    /**
+     * Screen hit test.
+     * @param x - The x coordinate of the screen point (normalized)
+     * @param y - The y coordinate of the screen point (normalized)
+     * @param type - The type of hit test
+     * @returns The hit result
+     */
+    screenHitTest(x: number, y: number, type: XRHitTestType): IXRHitResult[];
+    private _hitTest;
+    private _hitTestPlane;
+    private _checkPointerWithinPlane;
+}

package/types/xr/feature/hitTest/XRHitTestType.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Enum for the types of hit test that can be performed.
+ * Note: currently only supports plane.
+ */
+export declare enum XRHitTestType {
+    /** None */
+    None = 0,
+    /** Tracked plane. */
+    Plane = 1,
+    /** Tracked mesh. */
+    Mesh = 2,
+    /** Tracked anchor. */
+    Anchor = 4,
+    /** All tracked objects. */
+    All = 7
+}

package/types/xr/feature/movementTracking/XRMovementTracking.d.ts

@@ -0,0 +1,18 @@
+import { XRManager } from "../../XRManager";
+import { XRFeature } from "../XRFeature";
+import { XRMovementTrackingMode } from "./XRMovementTrackingMode";
+/**
+ * The manager of XR movement tracking.
+ */
+export declare class XRMovementTracking extends XRFeature {
+    private _trackingMode;
+    /**
+     * Get the tracking mode.
+     */
+    get trackingMode(): XRMovementTrackingMode;
+    /**
+     * @param xrManager - The xr manager
+     * @param trackingMode - The tracking mode
+     */
+    constructor(xrManager: XRManager, trackingMode?: XRMovementTrackingMode);
+}

package/types/xr/feature/movementTracking/XRMovementTrackingManager.d.ts

@@ -0,0 +1,10 @@
+import { IXRMovementTracking, IXRMovementTrackingDescriptor } from "@galacean/engine-design";
+import { XRMovementTrackingMode } from "./XRMovementTrackingMode";
+import { XRFeatureManager } from "../XRFeatureManager";
+export declare class XRMovementTrackingManager extends XRFeatureManager<IXRMovementTrackingDescriptor, IXRMovementTracking> {
+    /**
+     * Get the tracking mode.
+     */
+    get trackingMode(): XRMovementTrackingMode;
+    set trackingMode(value: XRMovementTrackingMode);
+}

package/types/xr/feature/movementTracking/XRMovementTrackingMode.d.ts

@@ -0,0 +1,5 @@
+export declare enum XRMovementTrackingMode {
+    None = 0,
+    Dof3 = 1,
+    Dof6 = 2
+}

package/types/xr/feature/trackable/XRRequestTrackingState.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Enum for the state of a request to track a trackable.
+ */
+export declare enum XRRequestTrackingState {
+    None = 0,
+    Submitted = 1,
+    Resolved = 2,
+    Rejected = 3,
+    Destroyed = 4,
+    WaitingDestroy = 5
+}

package/types/xr/feature/trackable/XRTrackableFeature.d.ts

@@ -0,0 +1,38 @@
+import { IXRTrackablePlatformFeature } from "@galacean/engine-design";
+import { XRTrackingState } from "../../input/XRTrackingState";
+import { XRFeature } from "../XRFeature";
+import { XRRequestTracking } from "./XRRequestTracking";
+import { XRTracked } from "./XRTracked";
+/**
+ * The base class of XR trackable manager.
+ */
+export declare abstract class XRTrackableFeature<T extends XRTracked, K extends XRRequestTracking<T>> extends XRFeature<IXRTrackablePlatformFeature<T, K>> {
+    protected _requestTrackings: K[];
+    protected _tracked: T[];
+    protected _added: T[];
+    protected _updated: T[];
+    protected _removed: T[];
+    protected _statusSnapshot: Record<number, XRTrackingState>;
+    private _listeners;
+    /**
+     * Returns the tracked objects.
+     */
+    get tracked(): readonly T[];
+    /**
+     * Add a listening function for tracked object changes.
+     * @param listener - The listening function
+     */
+    addChangedListener(listener: (added: readonly T[], updated: readonly T[], removed: readonly T[]) => void): void;
+    /**
+     * Remove a listening function of tracked object changes.
+     * @param listener - The listening function
+     */
+    removeChangedListener(listener: (added: readonly T[], updated: readonly T[], removed: readonly T[]) => void): void;
+    _onUpdate(): void;
+    _onSessionStop(): void;
+    _onSessionExit(): void;
+    _onDestroy(): void;
+    protected _addRequestTracking(requestTracking: K): void;
+    protected _removeRequestTracking(requestTracking: K): void;
+    protected _removeAllRequestTrackings(): void;
+}