@galacean/engine-core 1.6.8 → 1.6.10

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

@@ -0,0 +1,61 @@
+import { Vector3 } from "@galacean/engine-math";
+import { Joint } from "./Joint";
+import { JointLimits } from "./JointLimits";
+import { JointMotor } from "./JointMotor";
+import { Entity } from "../../Entity";
+/**
+ * A joint which behaves in a similar way to a hinge or axle.
+ */
+export declare class HingeJoint extends Joint {
+    private _axis;
+    private _hingeFlags;
+    private _useSpring;
+    private _jointMotor;
+    private _limits;
+    private _angle;
+    private _velocity;
+    /**
+     * The Direction of the axis around which the hingeJoint.
+     */
+    get axis(): Vector3;
+    set axis(value: Vector3);
+    /**
+     * The current angle in degrees of the joint relative to its rest position.
+     */
+    get angle(): number;
+    /**
+     * The angular velocity of the joint in degrees per second.
+     */
+    get velocity(): Readonly<number>;
+    /**
+     * Enables the joint's limits. Disabled by default.
+     */
+    get useLimits(): boolean;
+    set useLimits(value: boolean);
+    /**
+     * Enables the joint's motor. Disabled by default.
+     */
+    get useMotor(): boolean;
+    set useMotor(value: boolean);
+    /**
+     * Enables the joint's spring. Disabled by default.
+     */
+    get useSpring(): boolean;
+    set useSpring(value: boolean);
+    /**
+     * The motor will apply a force up to a maximum force to achieve the target velocity in degrees per second.
+     */
+    get motor(): JointMotor;
+    set motor(value: JointMotor);
+    /**
+     * Limit of angular rotation (in degrees) on the hinge joint.
+     */
+    get limits(): JointLimits;
+    set limits(value: JointLimits);
+    constructor(entity: Entity);
+    protected _createJoint(): void;
+    protected _syncNative(): void;
+    private _onMotorChanged;
+    private _onLimitsChanged;
+    private _onAxisChanged;
+}

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

@@ -0,0 +1,81 @@
+import { IJoint } from "@galacean/engine-design";
+import { Vector3 } from "@galacean/engine-math";
+import { Component } from "../../Component";
+import { Entity } from "../../Entity";
+import { Collider } from "../Collider";
+/**
+ * A base class providing common functionality for joints.
+ * @decorator `@dependentComponents(Collider, DependentMode.CheckOnly)`
+ */
+export declare abstract class Joint extends Component {
+    private static _tempVector3;
+    private static _tempQuat;
+    private static _tempMatrix;
+    protected _colliderInfo: JointColliderInfo;
+    protected _connectedColliderInfo: JointColliderInfo;
+    protected _nativeJoint: IJoint;
+    private _force;
+    private _torque;
+    private _automaticConnectedAnchor;
+    /**
+     * The connected collider.
+     */
+    get connectedCollider(): Collider;
+    set connectedCollider(value: Collider);
+    /**
+     * The anchor position.
+     */
+    get anchor(): Vector3;
+    set anchor(value: Vector3);
+    /**
+     * The connected anchor position.
+     * @remarks If connectedCollider is set, this anchor is relative offset, or the anchor is world position.
+     * The connectedAnchor is automatically calculated, if you want to set it manually, please set automaticConnectedAnchor to false
+     */
+    get connectedAnchor(): Vector3;
+    set connectedAnchor(value: Vector3);
+    /**
+     * Whether or not to calculate the connectedAnchor automatically, if true, the connectedAnchor will be calculated automatically to match the global position of the anchor property.
+     */
+    get automaticConnectedAnchor(): boolean;
+    set automaticConnectedAnchor(value: boolean);
+    /**
+     *  The scale to apply to the mass of collider 0 for resolving this constraint.
+     */
+    get connectedMassScale(): number;
+    set connectedMassScale(value: number);
+    /**
+     * The scale to apply to the mass of collider 1 for resolving this constraint.
+     */
+    get massScale(): number;
+    set massScale(value: number);
+    /**
+     * The scale to apply to the inertia of collider0 for resolving this constraint.
+     */
+    get connectedInertiaScale(): number;
+    set connectedInertiaScale(value: number);
+    /**
+     * The scale to apply to the inertia of collider1 for resolving this constraint.
+     */
+    get inertiaScale(): number;
+    set inertiaScale(value: number);
+    /**
+     * The maximum force the joint can apply before breaking.
+     */
+    get breakForce(): number;
+    set breakForce(value: number);
+    /**
+     * The maximum torque the joint can apply before breaking.
+     */
+    get breakTorque(): number;
+    set breakTorque(value: number);
+    constructor(entity: Entity);
+    protected abstract _createJoint(): void;
+    protected _syncNative(): void;
+    private _calculateConnectedAnchor;
+    private _handleConnectedAnchorChanged;
+    private _onSelfTransformChanged;
+    private _onConnectedTransformChanged;
+    private _updateRotation;
+    private _updateActualAnchor;
+}

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

@@ -0,0 +1,39 @@
+import { UpdateFlagManager } from "../../UpdateFlagManager";
+/**
+ * JointLimits is used to limit the joints angle.
+ */
+export declare class JointLimits {
+    /** @internal */
+    _updateFlagManager: UpdateFlagManager;
+    private _max;
+    private _min;
+    private _contactDistance;
+    private _stiffness;
+    private _damping;
+    /**
+     * The upper angular limit (in degrees) of the joint.
+     */
+    get max(): number;
+    set max(value: number);
+    /**
+     * The lower angular limit (in degrees) of the joint.
+     */
+    get min(): number;
+    set min(value: number);
+    /**
+     * Distance inside the limit value at which the limit will be considered to be active by the solver.
+     * Default is the lesser of 0.1 radians, and 0.49 * (upperLimit - lowerLimit)
+     */
+    get contactDistance(): number;
+    set contactDistance(value: number);
+    /**
+     * The spring forces used to reach the target position.
+     */
+    get stiffness(): number;
+    set stiffness(value: number);
+    /**
+     * The damper force uses to dampen the spring.
+     */
+    get damping(): number;
+    set damping(value: number);
+}

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

@@ -0,0 +1,32 @@
+import { UpdateFlagManager } from "../../UpdateFlagManager";
+/**
+ * The JointMotor is used to motorize a joint.
+ */
+export declare class JointMotor {
+    /** @internal */
+    _updateFlagManager: UpdateFlagManager;
+    private _targetVelocity;
+    private _forceLimit;
+    private _gearRatio;
+    private _freeSpin;
+    /**
+     * The motor will apply a force up to force to achieve targetVelocity.
+     */
+    get targetVelocity(): number;
+    set targetVelocity(value: number);
+    /**
+     * The force limit.
+     */
+    get forceLimit(): number;
+    set forceLimit(value: number);
+    /**
+     * Gear ration for the motor
+     */
+    get gearRatio(): number;
+    set gearRatio(value: number);
+    /**
+     * If freeSpin is enabled the motor will only accelerate but never slow down.
+     */
+    get freeSpin(): boolean;
+    set freeSpin(value: boolean);
+}

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

@@ -0,0 +1,38 @@
+import { Joint } from "./Joint";
+/**
+ * A joint that maintains an upper or lower bound (or both) on the distance between two points on different objects.
+ */
+export declare class SpringJoint extends Joint {
+    private _minDistance;
+    private _maxDistance;
+    private _tolerance;
+    private _stiffness;
+    private _damping;
+    /**
+     * The minimum distance.
+     */
+    get minDistance(): number;
+    set minDistance(value: number);
+    /**
+     * The maximum distance.
+     */
+    get maxDistance(): number;
+    set maxDistance(value: number);
+    /**
+     * The distance beyond the allowed range at which the joint becomes active.
+     */
+    get tolerance(): number;
+    set tolerance(value: number);
+    /**
+     * The spring strength of the joint.
+     */
+    get stiffness(): number;
+    set stiffness(value: number);
+    /**
+     * The degree of damping of the joint spring of the joint.
+     */
+    get damping(): number;
+    set damping(value: number);
+    protected _createJoint(): void;
+    protected _syncNative(): void;
+}

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

@@ -0,0 +1,6 @@
+export { Joint } from "./Joint";
+export { FixedJoint } from "./FixedJoint";
+export { HingeJoint } from "./HingeJoint";
+export { SpringJoint } from "./SpringJoint";
+export { JointLimits } from "./JointLimits";
+export { JointMotor } from "./JointMotor";

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

@@ -0,0 +1,16 @@
+import { ColliderShape } from "./ColliderShape";
+import { Vector3 } from "@galacean/engine-math";
+/**
+ * Physical collider shape for box.
+ */
+export declare class BoxColliderShape extends ColliderShape {
+    private _size;
+    /**
+     * Size of box shape.
+     */
+    get size(): Vector3;
+    set size(value: Vector3);
+    constructor();
+    protected _syncNative(): void;
+    private _setSize;
+}

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

@@ -0,0 +1,27 @@
+import { ColliderShape } from "./ColliderShape";
+import { ColliderShapeUpAxis } from "../enums/ColliderShapeUpAxis";
+/**
+ * Physical collider shape for capsule.
+ */
+export declare class CapsuleColliderShape extends ColliderShape {
+    private _radius;
+    private _height;
+    private _upAxis;
+    /**
+     * Radius of capsule.
+     */
+    get radius(): number;
+    set radius(value: number);
+    /**
+     * Height of capsule.
+     */
+    get height(): number;
+    set height(value: number);
+    /**
+     * Up axis of capsule.
+     */
+    get upAxis(): ColliderShapeUpAxis;
+    set upAxis(value: ColliderShapeUpAxis);
+    constructor();
+    protected _syncNative(): void;
+}

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

@@ -0,0 +1,61 @@
+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 implements ICustomClone {
+    private static _idGenerator;
+    protected _id: number;
+    protected _material: PhysicsMaterial;
+    private _isTrigger;
+    private _rotation;
+    private _position;
+    private _contactOffset;
+    /**
+     * Collider owner of this shape.
+     */
+    get collider(): Collider;
+    /**
+     * Unique id for this shape.
+     */
+    get id(): number;
+    /**
+     * Contact offset for this shape, the value must be greater than or equal to 0.
+     * @defaultValue 0.02
+     */
+    get contactOffset(): number;
+    set contactOffset(value: number);
+    /**
+     * Physical material, material can't be null.
+     */
+    get material(): PhysicsMaterial;
+    set material(value: PhysicsMaterial);
+    /**
+     * The local rotation of this ColliderShape, in degrees.
+     */
+    get rotation(): Vector3;
+    set rotation(value: Vector3);
+    /**
+     * The local position of this ColliderShape.
+     */
+    get position(): Vector3;
+    set position(value: Vector3);
+    /**
+     * True for TriggerShape, false for SimulationShape.
+     */
+    get isTrigger(): boolean;
+    set isTrigger(value: boolean);
+    protected constructor();
+    /**
+     * Get the distance and the closest point on the shape from a point.
+     * @param point - Location in world space you want to find the closest point to
+     * @param outClosestPoint - The closest point on the shape in world space
+     * @returns The distance between the point and the shape
+     */
+    getClosestPoint(point: Vector3, outClosestPoint: Vector3): number;
+    protected _syncNative(): void;
+    private _setPosition;
+    private _setRotation;
+}

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

@@ -0,0 +1,9 @@
+import { Vector3 } from "@galacean/engine-math";
+import { ColliderShape } from "./ColliderShape";
+/**
+ * Physical collider shape plane.
+ */
+export declare class PlaneColliderShape extends ColliderShape {
+    constructor();
+    getClosestPoint(point: Vector3, closestPoint: Vector3): number;
+}

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

@@ -0,0 +1,14 @@
+import { ColliderShape } from "./ColliderShape";
+/**
+ * Physical collider shape for sphere.
+ */
+export declare class SphereColliderShape extends ColliderShape {
+    private _radius;
+    /**
+     * Radius of sphere shape.
+     */
+    get radius(): number;
+    set radius(value: number);
+    constructor();
+    protected _syncNative(): void;
+}

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

@@ -0,0 +1,5 @@
+export { ColliderShape } from "./ColliderShape";
+export { BoxColliderShape } from "./BoxColliderShape";
+export { SphereColliderShape } from "./SphereColliderShape";
+export { PlaneColliderShape } from "./PlaneColliderShape";
+export { CapsuleColliderShape } from "./CapsuleColliderShape";

package/types/postProcess/FinalPass.d.ts

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

package/types/postProcess/PostProcess.d.ts

@@ -0,0 +1,64 @@
+import { Component } from "../Component";
+import { Layer } from "../Layer";
+import { PostProcessEffect } from "./PostProcessEffect";
+/**
+ * Post Process component can be used for global or local post-processing.
+ */
+export declare class PostProcess extends Component {
+    /**
+     * The layer to which the PostProcess belongs.
+     */
+    layer: Layer;
+    /**
+     * The outer distance to start blending from, only takes effect when the `isGlobal` is false.
+     */
+    blendDistance: number;
+    private _priority;
+    private _isGlobal;
+    /**
+     * Whether the PostProcess is global.
+     * @remarks
+     * Specifies whether to apply the PostProcess to the entire Scene or in Colliders.
+     * Only support local PostProcess in physics enabled Scenes.
+     */
+    get isGlobal(): boolean;
+    set isGlobal(value: boolean);
+    /**
+     * A value which determines which PostProcess is being used when PostProcess have an equal amount of influence on the Scene.
+     * @remarks
+     * PostProcess with a higher priority will override lower ones.
+     */
+    get priority(): number;
+    set priority(value: number);
+    /**
+     * Get the PostProcessEffect by type.
+     * @param type - The type of PostProcessEffect
+     * @returns The PostProcessEffect found
+     */
+    getEffect<T extends typeof PostProcessEffect>(type: T): InstanceType<T>;
+    /**
+     * Add a PostProcessEffect to the PostProcess.
+     * @remarks Only one effect of the same type can be added to the PostProcess.
+     * @param type - The type of PostProcessEffect
+     * @returns The PostProcessEffect added
+     */
+    addEffect<T extends typeof PostProcessEffect>(type: T): InstanceType<T>;
+    /**
+     * Remove a PostProcessEffect from the PostProcess.
+     * @param type - The type of PostProcessEffect
+     * @returns The PostProcessEffect removed
+     */
+    removeEffect<T extends typeof PostProcessEffect>(type: T): InstanceType<T>;
+    /**
+     * @inheritdoc
+     */
+    _onEnableInScene(): void;
+    /**
+     * @inheritdoc
+     */
+    _onDisableInScene(): void;
+    /**
+     * @inheritdoc
+     */
+    _onDestroy(): void;
+}

package/types/postProcess/PostProcessEffect.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The base class for post process effect.
+ */
+export declare class PostProcessEffect {
+    private _enabled;
+    private _parameters;
+    private _parameterInitialized;
+    /**
+     * Indicates whether the post process effect is enabled.
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /**
+     * Whether the post process effect is valid.
+     * @remarks
+     * This method can be overridden to control the effect's real validity.
+     */
+    isValid(): boolean;
+    /**
+     * Get all parameters of the post process effect.
+     * @remarks
+     * Only get the parameters that are initialized in the constructor.
+     * It will don't take effect if you add a new parameter after the post process effect is created, such as `effect.** = new PostProcessEffectParameter(1)`
+     */
+    private _getParameters;
+}

package/types/postProcess/PostProcessEffectParameter.d.ts

@@ -0,0 +1,119 @@
+import { Color, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
+import { Texture } from "../texture";
+/**
+ * Represents a parameter of a post process effect.
+ * @remarks
+ * The parameter will be mixed to a final value and be used in post process manager.
+ */
+export declare abstract class PostProcessEffectParameter<T> {
+    /**
+     * Whether the parameter is enabled.
+     */
+    enabled: boolean;
+    protected _needLerp: boolean;
+    protected _value: T;
+    /**
+     * The value of the parameter.
+     */
+    get value(): T;
+    set value(value: T);
+    constructor(value: T, needLerp?: boolean);
+}
+/**
+ * Represents a float parameter of a post process effect.
+ */
+export declare class PostProcessEffectFloatParameter extends PostProcessEffectParameter<number> {
+    readonly min: number;
+    readonly max: number;
+    get value(): number;
+    set value(v: number);
+    /**
+     * Create a new float parameter.
+     * @param value - The default value of the parameter
+     * @param _min - The minimum value of the parameter, default is Number.NEGATIVE_INFINITY
+     * @param _max - The maximum value of the parameter, default is Number.POSITIVE_INFINITY
+     * @param needLerp - Whether the parameter needs to be lerp, default is true
+     */
+    constructor(value: number, min?: number, max?: number, needLerp?: boolean);
+    _lerp(to: number, factor: number): void;
+}
+/**
+ * Represents a boolean parameter of a post process effect.
+ */
+export declare class PostProcessEffectBoolParameter extends PostProcessEffectParameter<boolean> {
+    /**
+     * Create a new boolean parameter.
+     * @param value - The default value of the parameter
+     */
+    constructor(value: boolean);
+}
+/**
+ * Represents a texture parameter of a post process effect.
+ */
+export declare class PostProcessEffectTextureParameter extends PostProcessEffectParameter<Texture> {
+    /**
+     * Create a new texture parameter.
+     * @param value - The default texture of the parameter
+     */
+    constructor(value: Texture);
+}
+/**
+ * Represents a color parameter of a post process effect.
+ */
+export declare class PostProcessEffectColorParameter extends PostProcessEffectParameter<Color> {
+    /**
+     * Create a new color parameter.
+     * @param value - The default color of the parameter
+     * @param needLerp - Whether the parameter needs to be lerp, default is true
+     */
+    constructor(value: Color, needLerp?: boolean);
+    _lerp(to: Color, factor: number): void;
+}
+/**
+ * Represents a vector2 parameter of a post process effect.
+ */
+export declare class PostProcessEffectVector2Parameter extends PostProcessEffectParameter<Vector2> {
+    /**
+     * Create a new vector2 parameter.
+     * @param value - The default vector2 of the parameter
+     * @param needLerp - Whether the parameter needs to be lerp, default is true
+     */
+    constructor(value: Vector2, needLerp?: boolean);
+    _lerp(to: Vector2, factor: number): void;
+}
+/**
+ * Represents a vector3 parameter of a post process effect.
+ */
+export declare class PostProcessEffectVector3Parameter extends PostProcessEffectParameter<Vector3> {
+    /**
+     * Create a new vector3 parameter.
+     * @param value - The default vector3 of the parameter
+     * @param needLerp - Whether the parameter needs to be lerp, default is true
+     */
+    constructor(value: Vector3, needLerp?: boolean);
+    _lerp(to: Vector3, factor: number): void;
+}
+/**
+ * Represents a vector4 parameter of a post process effect.
+ */
+export declare class PostProcessEffectVector4Parameter extends PostProcessEffectParameter<Vector4> {
+    /**
+     * Create a new vector4 parameter.
+     * @param value - The default vector4 of the parameter
+     * @param needLerp - Whether the parameter needs to be lerp, default is true
+     */
+    constructor(value: Vector4, needLerp?: boolean);
+    _lerp(to: Vector4, factor: number): void;
+}
+/**
+ * Represents a enum parameter of a post process effect.
+ */
+export declare class PostProcessEffectEnumParameter<T> extends PostProcessEffectParameter<T> {
+    readonly enumType: Record<string, number | string>;
+    /**
+     * Create a new enum parameter.
+     * @param enumType - The type of the enum
+     * @param value - The default enum value of the parameter
+     */
+    constructor(enumType: Record<string, number | string>, value: T);
+}

package/types/postProcess/PostProcessManager.d.ts

@@ -0,0 +1,38 @@
+import { Scene } from "../Scene";
+import { PostProcessEffect } from "./PostProcessEffect";
+/**
+ * A global manager of the PostProcess.
+ */
+export declare class PostProcessManager {
+    readonly scene: Scene;
+    private static _tempColliders;
+    private static _tempVector3;
+    private _activePostProcesses;
+    private _swapRenderTarget;
+    private _srcRenderTarget;
+    private _destRenderTarget;
+    private _currentSourceRenderTarget;
+    private _currentDestRenderTarget;
+    private _blendEffectMap;
+    private _defaultEffectMap;
+    private _remainActivePassCount;
+    private _outputRenderTarget;
+    /**
+     * Create a PostProcessManager.
+     * @param scene - Scene to which the current PostProcessManager belongs
+     */
+    constructor(scene: Scene);
+    /**
+     * Get the blend effect by type.
+     * @remarks
+     * The blend effect is a post process effect that is used to blend all result of the effects by the type.
+     * @param type - The type of PostProcessEffect
+     * @returns The PostProcessEffect instance found
+     */
+    getBlendEffect<T extends typeof PostProcessEffect>(type: T): InstanceType<T>;
+    private _sortActivePostProcess;
+    private _resetDefaultValue;
+    private _initSwapRenderTarget;
+    private _swapRT;
+    private _getCurrentSourceTexture;
+}