@galacean/engine-core 1.1.0-alpha.1 → 1.1.0-alpha.3

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

@@ -0,0 +1,27 @@
+import { IClone } from "@galacean/engine-design";
+import { ParticleCurveMode } from "../enums/ParticleCurveMode";
+/**
+ * Particle curve.
+ */
+export declare class ParticleCurve implements IClone {
+    /** 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/particle/moudules/ParticleGradient.d.ts

@@ -0,0 +1,28 @@
+import { IClone } from "@galacean/engine-design";
+import { Color } from "@galacean/engine-math";
+import { ParticleGradientMode } from "../enums/ParticleGradientMode";
+/**
+ * Particle curve.
+ */
+export declare class ParticleGradient implements IClone {
+    /** The curve mode. */
+    mode: ParticleGradientMode;
+    color: Color;
+    colorMin: Color;
+    colorMax: Color;
+    /**
+     * Query the color at the specified time.
+     * @param time - Normalized time at which to evaluate the gradient, Valid when `mode` is set to `Gradient` or `TwoGradients`
+     * @param lerpFactor - Lerp factor between two colors or gradients, Valid when `mode` is set to `TwoColors` or `TwoGradients`
+     * @param out - The result color
+     */
+    evaluate(time: number, lerpFactor: number, out: Color): void;
+    /**
+     * @inheritDoc
+     */
+    cloneTo(destEmission: ParticleGradient): void;
+    /**
+     * @inheritDoc
+     */
+    clone(): ParticleGradient;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Shape module of `ParticleSystem`.
+ */
+export declare class ShapeModule {
+    /** Specifies whether the Shape Module is enabled or disabled. */
+    enabled: boolean;
+}

package/types/particle/moudules/shape/BaseShape.d.ts

@@ -0,0 +1,28 @@
+import { IClone } from "@galacean/engine-design";
+import { BoundingBox, Rand } from "@galacean/engine-math";
+import { ParticleShapeType } from "./enums/ParticleShapeType";
+/**
+ * Configures the initial positions and directions of particles.
+ */
+export declare class BaseShape implements IClone {
+    /** The type of shape to emit particles from. */
+    shapeType: ParticleShapeType;
+    /** Specifies whether the ShapeModule is enabled or disabled. */
+    enable: boolean;
+    /** Randomizes the starting direction of particles. */
+    randomDirectionAmount: number;
+    protected _rand: Rand;
+    constructor(randSeed?: number);
+    /**
+     * @override
+     * @inheritDoc
+     */
+    cloneTo(destShape: BaseShape): void;
+    /**
+     * @override
+     * @inheritDoc
+     */
+    clone(): BaseShape;
+    protected _getShapeBoundBox(boundBox: BoundingBox): void;
+    protected _getSpeedBoundBox(boundBox: BoundingBox): void;
+}

package/types/particle/moudules/shape/BoxShape.d.ts

@@ -0,0 +1,20 @@
+import { BoundingBox, Vector3 } from "@galacean/engine-math";
+import { BaseShape } from "./BaseShape";
+/**
+ * Box emitter shape
+ */
+export declare class BoxShape extends BaseShape {
+    /** Thickness of the box to emit particles from. */
+    boxThickness: Vector3;
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected _getShapeBoundBox(boundBox: BoundingBox): void;
+    /**
+     * @inheritDoc
+     */
+    protected _getSpeedBoundBox(boundBox: BoundingBox): void;
+    cloneTo(destShape: BoxShape): void;
+    clone(): BoxShape;
+}

package/types/particle/moudules/shape/CircleShape.d.ts

@@ -0,0 +1,27 @@
+import { BoundingBox, Vector2, Vector3 } from "@galacean/engine-math";
+import { BaseShape } from "./BaseShape";
+import { ParticleShapeMultiModeValue } from "./enums/ParticleShapeMultiModeValue";
+/**
+ * Circle Particle Emitter
+ */
+export declare class CircleShape extends BaseShape {
+    protected static _tempPositionPoint: Vector2;
+    /** Radius of the shape to emit particles from. */
+    radius: number;
+    /** Angle of the circle arc to emit particles from. */
+    arc: number;
+    /** The mode to generate particles around the arc. */
+    arcMode: ParticleShapeMultiModeValue;
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected _getShapeBoundBox(boundBox: BoundingBox): void;
+    /**
+     * @inheritDoc
+     */
+    protected _getSpeedBoundBox(boundBox: BoundingBox): void;
+    _generatePositionAndDirection(position: Vector3, direction: Vector3): void;
+    cloneTo(destShape: CircleShape): void;
+    clone(): CircleShape;
+}

package/types/particle/moudules/shape/ConeShape.d.ts

@@ -0,0 +1,35 @@
+import { BoundingBox, Vector2, Vector3 } from "@galacean/engine-math";
+import { BaseShape } from "./BaseShape";
+export declare enum ConeEmitType {
+    Base = 0,
+    BaseShell = 1,
+    Volume = 2,
+    VolumeShell = 3
+}
+/**
+ * Cone particle emitter
+ */
+export declare class ConeShape extends BaseShape {
+    protected static _tempPositionPoint: Vector2;
+    protected static _tempDirectionPoint: Vector2;
+    /** Angle of the cone to emit particles from. */
+    angle: number;
+    /** Radius of the shape to emit particles from. */
+    radius: number;
+    /** Length of the cone to emit particles from. */
+    length: number;
+    /** Cone emitter subtype */
+    emitType: ConeEmitType;
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected _getShapeBoundBox(boundBox: BoundingBox): void;
+    /**
+     * @inheritDoc
+     */
+    protected _getSpeedBoundBox(boundBox: BoundingBox): void;
+    _generatePositionAndDirection(position: Vector3, direction: Vector3): void;
+    cloneTo(destShape: ConeShape): void;
+    clone(): ConeShape;
+}

package/types/particle/moudules/shape/HemisphereShape.d.ts

@@ -0,0 +1,23 @@
+import { BoundingBox, Vector3 } from "@galacean/engine-math";
+import { BaseShape } from "./BaseShape";
+/**
+ * Hemisphere emitter
+ */
+export declare class HemisphereShape extends BaseShape {
+    /** Radius of the shape to emit particles from. */
+    radius: number;
+    /** Whether emit from shell */
+    emitFromShell: boolean;
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected _getShapeBoundBox(boundBox: BoundingBox): void;
+    /**
+     * @inheritDoc
+     */
+    protected _getSpeedBoundBox(boundBox: BoundingBox): void;
+    _generatePositionAndDirection(position: Vector3, direction: Vector3): void;
+    cloneTo(destShape: HemisphereShape): void;
+    clone(): HemisphereShape;
+}

package/types/particle/moudules/shape/ShapeUtils.d.ts

@@ -0,0 +1 @@
+export {};

package/types/particle/moudules/shape/SphereShape.d.ts

@@ -0,0 +1,23 @@
+import { BoundingBox, Rand, Vector3 } from "@galacean/engine-math";
+import { BaseShape } from "./BaseShape";
+/**
+ * Sphere emitter
+ */
+export declare class SphereShape extends BaseShape {
+    /** Radius of the shape to emit particles from. */
+    radius: number;
+    /** Whether emit from shell */
+    emitFromShell: boolean;
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected _getShapeBoundBox(boundBox: BoundingBox): void;
+    /**
+     * @inheritDoc
+     */
+    protected _getSpeedBoundBox(boundBox: BoundingBox): void;
+    _generatePositionAndDirection(position: Vector3, direction: Vector3, rand?: Rand, randomSeeds?: Uint32Array): void;
+    cloneTo(destShape: SphereShape): void;
+    clone(): SphereShape;
+}

package/types/particle/moudules/shape/enums/ParticleShapeMultiModeValue.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The mode used to generate new points in a shape.
+ */
+export declare enum ParticleShapeMultiModeValue {
+    /** Generate points randomly. (Default) */
+    Random = 0,
+    /** Animate the emission point around the shape. */
+    Loop = 1
+}

package/types/particle/moudules/shape/enums/ParticleShapeType.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The emission shape.
+ */
+export declare enum ParticleShapeType {
+    /** Emit from the volume of a box. */
+    Box = 0,
+    /** Emit from a circle. */
+    Circle = 1,
+    /** Emit from the base of a cone. */
+    Cone = 2,
+    /** Emit from a half-sphere. */
+    Hemisphere = 3,
+    /** Emit from a sphere. */
+    Sphere = 4
+}

package/types/particle/moudules/shape/index.d.ts

@@ -0,0 +1,5 @@
+export { BoxShape } from "./BoxShape";
+export { CircleShape } from "./CircleShape";
+export { ConeShape, ConeEmitType } from "./ConeShape";
+export { HemisphereShape } from "./HemisphereShape";
+export { SphereShape } from "./SphereShape";

package/types/physics/PhysicsScene.d.ts

@@ -9,6 +9,7 @@ export declare class PhysicsScene {
     private static _collision;
     private _scene;
     private _restTime;
+    private _fixedTimeStep;
     private _colliders;
     private _gravity;
     private _nativePhysicsScene;
@@ -18,13 +19,16 @@ export declare class PhysicsScene {
     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(scene: Scene);
     /**
      * Casts a ray through the Scene and returns the first hit.

package/types/shaderlib/particle/index.d.ts

@@ -0,0 +1,14 @@
+declare const _default: {
+    particle_common: string;
+    velocity_over_lifetime_module: string;
+    rotation_over_lifetime_module: string;
+    size_over_lifetime_module: string;
+    color_over_lifetime_module: string;
+    texture_sheet_animation_module: string;
+    sphere_billboard: string;
+    stretched_billboard: string;
+    vertical_billboard: string;
+    horizontal_billboard: string;
+    particle_mesh: string;
+};
+export default _default;

package/types/shadow/PipelinePass.d.ts

@@ -0,0 +1,16 @@
+import { Engine } from "../Engine";
+import { CullingResults } from "../RenderPipeline/CullingResults";
+import { RenderContext } from "../RenderPipeline/RenderContext";
+/**
+ * PipelinePass is a base class for all pipeline passes.
+ */
+export declare abstract class PipelinePass {
+    protected _engine: Engine;
+    constructor(engine: Engine);
+    /**
+     * Called before rendering a camera, override this method to configure the camera If you need to configure the camera clear flag or render target.
+     * @param context - Rendering context
+     * @param cullingResults - Culling results
+     */
+    abstract onRender(context: RenderContext, cullingResults: CullingResults): void;
+}

package/types/utils/BoolUpdateFlag.d.ts

@@ -0,0 +1,12 @@
+import { UpdateFlag } from "./UpdateFlag";
+/**
+ * Bool update flag.
+ */
+export declare class BoolUpdateFlag extends UpdateFlag {
+    /** Bool flag. */
+    flag: boolean;
+    /**
+     * @inheritdoc
+     */
+    dispatch(): void;
+}

package/types/utils/DisorderedArray.d.ts

@@ -0,0 +1,18 @@
+/**
+ * High-performance unordered array, delete uses exchange method to improve performance, internal capacity only increases.
+ */
+export declare class DisorderedArray<T> {
+    _elements: T[];
+    length: number;
+    constructor(count?: number);
+    add(element: T): void;
+    delete(element: T): void;
+    get(index: number): T;
+    /**
+     *
+     * @param index
+     * @returns The replaced item is used to reset its index.
+     */
+    deleteByIndex(index: number): T;
+    garbageCollection(): void;
+}

package/types/utils/UpdateFlag.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Used to update tags.
+ */
+export declare abstract class UpdateFlag {
+    /**
+     * Dispatch.
+     * @param bit - Bit
+     * @param param - Parameter
+     */
+    abstract dispatch(bit?: number, param?: Object): void;
+    /**
+     * Clear.
+     */
+    clearFromManagers(): void;
+    /**
+     * Destroy.
+     */
+    destroy(): void;
+    private _removeFromManagers;
+}

package/types/utils/UpdateFlagManager.d.ts

@@ -0,0 +1 @@
+export {};

package/types/utils/Utils.d.ts

@@ -0,0 +1,31 @@
+export declare class Utils {
+    /**
+     * Fast remove an element from array.
+     * @param array - Array
+     * @param item - Element
+     */
+    static removeFromArray(array: any[], item: any): boolean;
+    /**
+     * Decodes a given Uint8Array into a string.
+     */
+    static decodeText(array: Uint8Array): string;
+    /**
+     * Judge whether the url is absolute url.
+     * @param url - The url to be judged.
+     * @returns Whether the url is absolute url.
+     */
+    static isAbsoluteUrl(url: string): boolean;
+    /**
+     * Get the values of an object.
+     */
+    static objectValues(obj: any): any[];
+    /**
+     * Convert a relative URL to an absolute URL based on a given base URL.
+     * @param baseUrl - The base url.
+     * @param relativeUrl - The relative url.
+     * @returns The resolved url.
+     */
+    static resolveAbsoluteUrl(baseUrl: string, relativeUrl: string): string;
+    private static _stringToPath;
+    private static _formatRelativePath;
+}

package/types/xr/XRManager.d.ts

@@ -0,0 +1,31 @@
+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;
+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/component/XRPoseDriver.d.ts

@@ -0,0 +1,10 @@
+import { Script } from "../../Script";
+import { EnumXRInputSource } from "../enum/EnumXRInputSource";
+import { EnumXRTrackingMode } from "../enum/EnumXRTrackingMode";
+export declare class XRPoseDriver extends Script {
+    source: EnumXRInputSource;
+    updateType: EnumXRTrackingMode;
+    private _xrManager;
+    onLateUpdate(): void;
+    onAwake(): void;
+}

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

@@ -0,0 +1,6 @@
+import { Matrix, Vector4 } from "@galacean/engine-math";
+import { XRDevice } from "./XRDevice";
+export declare class XRCamera extends XRDevice {
+    project: Matrix;
+    viewport: Vector4;
+}

package/types/xr/data/XRDevice.d.ts

@@ -0,0 +1,9 @@
+import { Matrix, Quaternion, Vector3 } from "@galacean/engine-math";
+import { EnumXRDevicePhase } from "../enum/EnumXRDevicePhase";
+export declare class XRDevice {
+    matrix: Matrix;
+    position: Vector3;
+    linearVelocity: Vector3;
+    quaternion: Quaternion;
+    phase: EnumXRDevicePhase;
+}

package/types/xr/data/XRHandle.d.ts

@@ -0,0 +1,10 @@
+import { XRDevice } from "./XRDevice";
+import { EnumXRButton } from "../enum/EnumXRButton";
+import { DisorderedArray } from "../../DisorderedArray";
+export declare class XRHandle extends XRDevice {
+    pressedButtons: EnumXRButton;
+    upMap: number[];
+    downMap: number[];
+    upList: DisorderedArray<EnumXRButton>;
+    downList: DisorderedArray<EnumXRButton>;
+}

package/types/xr/enum/EnumXRButton.d.ts

@@ -0,0 +1,5 @@
+export declare enum EnumXRButton {
+    None = 0,
+    Select = 1,
+    Squeeze = 2
+}

package/types/xr/enum/EnumXRDevicePhase.d.ts

@@ -0,0 +1,4 @@
+export declare enum EnumXRDevicePhase {
+    active = 0,
+    leave = 1
+}

package/types/xr/enum/EnumXRFeature.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ */
+export declare enum EnumXRFeature {
+    input = 0,
+    camera = 1,
+    imageTracking = 2,
+    objectTracking = 3
+}

package/types/xr/enum/EnumXRInputSource.d.ts

@@ -0,0 +1,8 @@
+export declare enum EnumXRInputSource {
+    Handler = 0,
+    LeftHandle = 1,
+    RightHandle = 2,
+    Eye = 3,
+    LeftEye = 4,
+    RightEye = 5
+}

package/types/xr/enum/EnumXRMode.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Modes for XR
+ */
+export declare enum EnumXRMode {
+    AR = 0,
+    VR = 1
+}

package/types/xr/enum/EnumXRSubsystem.d.ts

@@ -0,0 +1,4 @@
+export declare enum EnumXRSubsystem {
+    input = 0,
+    imageTracking = 1
+}

package/types/xr/enum/EnumXRTrackingMode.d.ts

@@ -0,0 +1,7 @@
+export declare enum EnumXRTrackingMode {
+    None = 0,
+    RotationOnly = 1,
+    PositionOnly = 2,
+    RotationAndPosition = 3,
+    Auto = 4
+}

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

@@ -0,0 +1,21 @@
+import { Camera } from "../../Camera";
+import { EnumXRInputSource } from "../enum/EnumXRInputSource";
+import { XRFeature } from "./XRFeature";
+export declare class XRCameraManager extends XRFeature {
+    private _cameras;
+    private _automaticNear;
+    private _customNear;
+    private _automaticFar;
+    private _customFar;
+    get near(): number;
+    set near(value: number);
+    get far(): number;
+    set far(value: number);
+    attachCamera(source: EnumXRInputSource, camera: Camera): void;
+    detachCamera(source: EnumXRInputSource): void;
+    getCamera(source: EnumXRInputSource): Camera;
+    onUpdate(): void;
+    onEnable(): void;
+    onDisable(): void;
+    onDestroy(): void;
+}

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

@@ -0,0 +1,29 @@
+import { Engine } from "../../Engine";
+export declare abstract class XRFeature {
+    protected _engine: Engine;
+    /**
+     * Enable an instance of a feature.
+     * This method needs to be override.
+     * @returns
+     */
+    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);
+}

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

@@ -0,0 +1,10 @@
+import { Entity } from "../../Entity";
+import { XRFeature } from "./XRFeature";
+export declare class XRImageTrackManager extends XRFeature {
+    addImage(): void;
+    removeImage(): void;
+    getTrackedObject(): Entity;
+    onEnable(): void;
+    onDisable(): void;
+    onDestroy(): void;
+}

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

@@ -0,0 +1,16 @@
+import { Engine } from "../../Engine";
+import { XRDevice } from "../data/XRDevice";
+import { EnumXRButton } from "../enum/EnumXRButton";
+import { EnumXRInputSource } from "../enum/EnumXRInputSource";
+import { XRFeature } from "./XRFeature";
+export declare class XRInputManager extends XRFeature {
+    private _subSystem;
+    getDevice<T extends XRDevice>(source: EnumXRInputSource): T;
+    isButtonDown(handedness: EnumXRInputSource, button: EnumXRButton): boolean;
+    isButtonUp(handedness: EnumXRInputSource, button: EnumXRButton): boolean;
+    isButtonHeldDown(handedness: EnumXRInputSource, button: EnumXRButton): boolean;
+    onEnable(): void;
+    onDisable(): void;
+    onDestroy(): void;
+    constructor(engine: Engine);
+}

package/types/xr/index.d.ts

@@ -0,0 +1,18 @@
+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";