@galacean/engine-core 0.9.0-beta.80

package/types/particle/ParticleRenderer.d.ts

@@ -0,0 +1,235 @@
+import { Vector3, Color } from "@galacean/engine-math";
+import { Texture } from "../texture";
+import { MeshRenderer } from "../mesh/MeshRenderer";
+/**
+ * Blend mode enums of the particle renderer's material.
+ */
+export declare enum ParticleRendererBlendMode {
+    Transparent = 0,
+    Additive = 1
+}
+/**
+ * Particle Renderer Component.
+ */
+export declare class ParticleRenderer extends MeshRenderer {
+    /** The max number of indices that Uint16Array can support. */
+    private static _uint16VertexLimit;
+    private static _getRandom;
+    private _vertexStride;
+    private _vertices;
+    private _vertexBuffer;
+    private _maxCount;
+    private _position;
+    private _positionRandomness;
+    private _positionArray;
+    private _velocity;
+    private _velocityRandomness;
+    private _acceleration;
+    private _accelerationRandomness;
+    private _color;
+    private _colorRandomness;
+    private _size;
+    private _sizeRandomness;
+    private _alpha;
+    private _alphaRandomness;
+    private _startAngle;
+    private _startAngleRandomness;
+    private _rotateVelocity;
+    private _rotateVelocityRandomness;
+    private _lifetime;
+    private _startTimeRandomness;
+    private _scale;
+    private _isOnce;
+    private _onceTime;
+    private _time;
+    private _isInit;
+    private _isStart;
+    private _updateDirtyFlag;
+    private _isRotateToVelocity;
+    private _isUseOriginColor;
+    private _isScaleByLifetime;
+    private _is2d;
+    private _isFadeIn;
+    private _isFadeOut;
+    private _playOnEnable;
+    private _blendMode;
+    /**
+     * Sprite sheet of texture.
+     */
+    spriteSheet: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }[];
+    /**
+     * Texture of particle.
+     */
+    get texture(): Texture;
+    set texture(texture: Texture);
+    /**
+     * Position of particles.
+     */
+    get position(): Vector3;
+    set position(value: Vector3);
+    /**
+     * Random range of positions.
+     */
+    get positionRandomness(): Vector3;
+    set positionRandomness(value: Vector3);
+    /**
+     * Array of fixed positions.
+     */
+    get positionArray(): Vector3[];
+    set positionArray(value: Vector3[]);
+    /**
+     * Velocity of particles.
+     */
+    get velocity(): Vector3;
+    set velocity(value: Vector3);
+    /**
+     * Random range of velocity.
+     */
+    get velocityRandomness(): Vector3;
+    set velocityRandomness(value: Vector3);
+    /**
+     * Acceleration of particles.
+     */
+    get acceleration(): Vector3;
+    set acceleration(value: Vector3);
+    /**
+     * Random range of acceleration.
+     */
+    get accelerationRandomness(): Vector3;
+    set accelerationRandomness(value: Vector3);
+    /**
+     * Color of particles.
+     */
+    get color(): Color;
+    set color(value: Color);
+    /**
+     * Random range of color.
+     */
+    get colorRandomness(): number;
+    set colorRandomness(value: number);
+    /**
+     * Size of particles.
+     */
+    get size(): number;
+    set size(value: number);
+    /**
+     * Random range of size.
+     */
+    get sizeRandomness(): number;
+    set sizeRandomness(value: number);
+    /**
+     * Alpha of particles.
+     */
+    get alpha(): number;
+    set alpha(value: number);
+    /**
+     * Random range of alpha.
+     */
+    get alphaRandomness(): number;
+    set alphaRandomness(value: number);
+    /**
+     * Angle of particles.
+     */
+    get angle(): number;
+    set angle(value: number);
+    /**
+     * Random range of angle.
+     */
+    get angleRandomness(): number;
+    set angleRandomness(value: number);
+    /**
+     * Rotate velocity of particles.
+     */
+    get rotateVelocity(): number;
+    set rotateVelocity(value: number);
+    /**
+     * Random range of rotate velocity.
+     */
+    get rotateVelocityRandomness(): number;
+    set rotateVelocityRandomness(value: number);
+    /**
+     * Lifetime of particles.
+     */
+    get lifetime(): number;
+    set lifetime(value: number);
+    /**
+     * Random range of start time.
+     */
+    get startTimeRandomness(): number;
+    set startTimeRandomness(value: number);
+    /**
+     * Scale factor of particles.
+     */
+    get scale(): number;
+    set scale(value: number);
+    /**
+     * Max count of particles.
+     */
+    get maxCount(): number;
+    set maxCount(value: number);
+    /**
+     * Whether play once.
+     */
+    get isOnce(): boolean;
+    set isOnce(value: boolean);
+    /**
+     * Whether follow the direction of velocity.
+     */
+    get isRotateToVelocity(): boolean;
+    set isRotateToVelocity(value: boolean);
+    /**
+     * Whether use origin color.
+     */
+    get isUseOriginColor(): boolean;
+    set isUseOriginColor(value: boolean);
+    /**
+     * Whether scale by lifetime.
+     */
+    get isScaleByLifetime(): boolean;
+    set isScaleByLifetime(value: boolean);
+    /**
+     * Whether 2D rendering.
+     */
+    get is2d(): boolean;
+    set is2d(value: boolean);
+    /**
+     * Whether fade in.
+     */
+    get isFadeIn(): boolean;
+    set isFadeIn(value: boolean);
+    /**
+     * Whether fade out.
+     */
+    get isFadeOut(): boolean;
+    set isFadeOut(value: boolean);
+    /**
+     * Whether play on enable.
+     */
+    get playOnEnable(): boolean;
+    set playOnEnable(value: boolean);
+    /**
+     * Blend mode of the particle renderer's material.
+     */
+    get blendMode(): ParticleRendererBlendMode;
+    set blendMode(value: ParticleRendererBlendMode);
+    constructor(props: any);
+    /**
+     * Start emitting.
+     */
+    start(): void;
+    /**
+     * Stop emitting.
+     */
+    stop(): void;
+    private _createMaterial;
+    private _createMesh;
+    private _updateBuffer;
+    private _updateSingleBuffer;
+    private _updateSingleUv;
+    private _onColorChanged;
+}

package/types/particle/index.d.ts

@@ -0,0 +1 @@
+export { ParticleRenderer, ParticleRendererBlendMode } from "./ParticleRenderer";

package/types/physics/CharacterController.d.ts

@@ -0,0 +1,53 @@
+import { Vector3 } from "@galacean/engine-math";
+import { Collider } from "./Collider";
+import { ControllerNonWalkableMode } from "./enums/ControllerNonWalkableMode";
+import { ColliderShape } from "./shape";
+/**
+ * The character controllers.
+ */
+export declare class CharacterController extends Collider {
+    private _stepOffset;
+    private _nonWalkableMode;
+    private _upDirection;
+    private _slopeLimit;
+    /**
+     * The step offset for the controller.
+     */
+    get stepOffset(): number;
+    set stepOffset(value: number);
+    /**
+     * The value of the non-walkable mode.
+     */
+    get nonWalkableMode(): ControllerNonWalkableMode;
+    set nonWalkableMode(value: ControllerNonWalkableMode);
+    /**
+     * The up direction for the controller.
+     */
+    get upDirection(): Vector3;
+    set upDirection(value: Vector3);
+    /**
+     * The slope limit for the controller.
+     */
+    get slopeLimit(): number;
+    set slopeLimit(value: number);
+    /**
+     * Moves the character using a "collide-and-slide" algorithm.
+     * @param disp - Displacement vector
+     * @param minDist - The minimum travelled distance to consider.
+     * @param elapsedTime - Time elapsed since last call
+     * @return flags - The ControllerCollisionFlag
+     */
+    move(disp: Vector3, minDist: number, elapsedTime: number): number;
+    /**
+     * Add collider shape on this controller.
+     * @param shape - Collider shape
+     * @override
+     */
+    addShape(shape: ColliderShape): void;
+    /**
+     * Remove all shape attached.
+     * @override
+     */
+    clearShapes(): void;
+    private _setUpDirection;
+}

package/types/physics/Collider.d.ts

@@ -0,0 +1,29 @@
+import { BoolUpdateFlag } from "../BoolUpdateFlag";
+import { Component } from "../Component";
+import { ColliderShape } from "./shape/ColliderShape";
+/**
+ * Base class for all colliders.
+ * @decorator `@dependentComponents(Transform)`
+ */
+export declare class Collider extends Component {
+    protected _updateFlag: BoolUpdateFlag;
+    protected _shapes: ColliderShape[];
+    /**
+     * The shapes of this collider.
+     */
+    get shapes(): Readonly<ColliderShape[]>;
+    /**
+     * Add collider shape on this collider.
+     * @param shape - Collider shape
+     */
+    addShape(shape: ColliderShape): void;
+    /**
+     * Remove a collider shape.
+     * @param shape - The collider shape.
+     */
+    removeShape(shape: ColliderShape): void;
+    /**
+     * Remove all shape attached.
+     */
+    clearShapes(): void;
+}

package/types/physics/Collision.d.ts

@@ -0,0 +1,4 @@
+import { ColliderShape } from "./shape";
+export declare class Collision {
+    shape: ColliderShape;
+}

package/types/physics/DynamicCollider.d.ts

@@ -0,0 +1,161 @@
+import { Quaternion, Vector3 } from "@galacean/engine-math";
+import { Collider } from "./Collider";
+/**
+ * A dynamic collider can act with self-defined movement or physical force.
+ */
+export declare class DynamicCollider extends Collider {
+    private _linearDamping;
+    private _angularDamping;
+    private _linearVelocity;
+    private _angularVelocity;
+    private _mass;
+    private _centerOfMass;
+    private _inertiaTensor;
+    private _maxAngularVelocity;
+    private _maxDepenetrationVelocity;
+    private _solverIterations;
+    private _isKinematic;
+    private _constraints;
+    private _collisionDetectionMode;
+    private _sleepThreshold;
+    /**
+     * The linear damping of the dynamic collider.
+     */
+    get linearDamping(): number;
+    set linearDamping(value: number);
+    /**
+     * The angular damping of the dynamic collider.
+     */
+    get angularDamping(): number;
+    set angularDamping(value: number);
+    /**
+     * The linear velocity vector of the dynamic collider measured in world unit per second.
+     */
+    get linearVelocity(): Vector3;
+    set linearVelocity(value: Vector3);
+    /**
+     * The angular velocity vector of the dynamic collider measured in radians per second.
+     */
+    get angularVelocity(): Vector3;
+    set angularVelocity(value: Vector3);
+    /**
+     * The mass of the dynamic collider.
+     */
+    get mass(): number;
+    set mass(value: number);
+    /**
+     * The center of mass relative to the transform's origin.
+     */
+    get centerOfMass(): Vector3;
+    set centerOfMass(value: Vector3);
+    /**
+     * The diagonal inertia tensor of mass relative to the center of mass.
+     */
+    get inertiaTensor(): Vector3;
+    set inertiaTensor(value: Vector3);
+    /**
+     * The maximum angular velocity of the collider measured in radians per second. (Default 7) range { 0, infinity }.
+     */
+    get maxAngularVelocity(): number;
+    set maxAngularVelocity(value: number);
+    /**
+     * Maximum velocity of a collider when moving out of penetrating state.
+     */
+    get maxDepenetrationVelocity(): number;
+    set maxDepenetrationVelocity(value: number);
+    /**
+     * The mass-normalized energy threshold, below which objects start going to sleep.
+     */
+    get sleepThreshold(): number;
+    set sleepThreshold(value: number);
+    /**
+     * The solverIterations determines how accurately collider joints and collision contacts are resolved.
+     */
+    get solverIterations(): number;
+    set solverIterations(value: number);
+    /**
+     * Controls whether physics affects the dynamic collider.
+     */
+    get isKinematic(): boolean;
+    set isKinematic(value: boolean);
+    /**
+     * The particular rigid dynamic lock flag.
+     */
+    get constraints(): DynamicColliderConstraints;
+    set constraints(value: DynamicColliderConstraints);
+    /**
+     * The colliders' collision detection mode.
+     */
+    get collisionDetectionMode(): CollisionDetectionMode;
+    set collisionDetectionMode(value: CollisionDetectionMode);
+    /**
+     * Apply a force to the DynamicCollider.
+     * @param force - The force make the collider move
+     */
+    applyForce(force: Vector3): void;
+    /**
+     * Apply a torque to the DynamicCollider.
+     * @param torque - The force make the collider rotate
+     */
+    applyTorque(torque: Vector3): void;
+    /**
+     * Moves kinematically controlled dynamic actors through the game world.
+     * @param position - The desired position for the kinematic actor
+     */
+    move(position: Vector3): void;
+    /**
+     * Moves kinematically controlled dynamic actors through the game world.
+     * @param rotation - The desired rotation for the kinematic actor
+     */
+    move(rotation: Quaternion): void;
+    /**
+     * Moves kinematically controlled dynamic actors through the game world.
+     * @param position - The desired position for the kinematic actor
+     * @param rotation - The desired rotation for the kinematic actor
+     */
+    move(position: Vector3, rotation: Quaternion): void;
+    /**
+     * Forces a collider to sleep at least one frame.
+     */
+    sleep(): void;
+    /**
+     * Forces a collider to wake up.
+     */
+    wakeUp(): void;
+    private _setLinearVelocity;
+    private _setAngularVelocity;
+    private _setCenterOfMass;
+    private _setInertiaTensor;
+}
+/**
+ * The collision detection mode constants.
+ */
+export declare enum CollisionDetectionMode {
+    /** Continuous collision detection is off for this dynamic collider. */
+    Discrete = 0,
+    /** Continuous collision detection is on for colliding with static mesh geometry. */
+    Continuous = 1,
+    /** Continuous collision detection is on for colliding with static and dynamic geometry. */
+    ContinuousDynamic = 2,
+    /** Speculative continuous collision detection is on for static and dynamic geometries */
+    ContinuousSpeculative = 3
+}
+/**
+ * Use these flags to constrain motion of dynamic collider.
+ */
+export declare enum DynamicColliderConstraints {
+    /** Not Freeze. */
+    None = 0,
+    /** Freeze motion along the X-axis. */
+    FreezePositionX = 1,
+    /** Freeze motion along the Y-axis. */
+    FreezePositionY = 2,
+    /** Freeze motion along the Z-axis. */
+    FreezePositionZ = 4,
+    /** Freeze rotation along the X-axis. */
+    FreezeRotationX = 8,
+    /** Freeze rotation along the Y-axis. */
+    FreezeRotationY = 16,
+    /** Freeze rotation along the Z-axis. */
+    FreezeRotationZ = 32
+}

package/types/physics/HitResult.d.ts

@@ -0,0 +1,15 @@
+import { Entity } from "../Entity";
+import { Vector3 } from "@galacean/engine-math";
+/**
+ * Structure used to get information back from a raycast or a sweep.
+ */
+export declare class HitResult {
+    /** The entity that was hit. */
+    entity: Entity;
+    /** The distance from the ray's origin to the impact point. */
+    distance: number;
+    /** The impact point in world space where the ray hit the collider. */
+    point: Vector3;
+    /** The normal of the surface the ray hit. */
+    normal: Vector3;
+}

package/types/physics/PhysicsManager.d.ts

@@ -0,0 +1,95 @@
+import { IPhysics } from "@galacean/engine-design";
+import { Ray, Vector3 } from "@galacean/engine-math";
+import { Engine } from "../Engine";
+import { Layer } from "../Layer";
+import { HitResult } from "./HitResult";
+/**
+ * A physics manager is a collection of colliders and constraints which can interact.
+ */
+export declare class PhysicsManager {
+    private _engine;
+    private _restTime;
+    private _colliders;
+    private _gravity;
+    private _nativePhysicsManager;
+    private _physicalObjectsMap;
+    private _onContactEnter;
+    private _onContactExit;
+    private _onContactStay;
+    private _onTriggerEnter;
+    private _onTriggerExit;
+    private _onTriggerStay;
+    /** The fixed time step in seconds at which physics are performed. */
+    fixedTimeStep: number;
+    /**
+     * The max allowed time step in seconds one frame.
+     *
+     * @remarks
+     * When the frame rate is low or stutter occurs, the maximum execution time of physics will not exceed this value.
+     * So physics will slow down a bit when performance hitch occurs.
+     */
+    maxAllowedTimeStep: number;
+    /**
+     * The gravity of physics scene.
+     */
+    get gravity(): Vector3;
+    set gravity(value: Vector3);
+    /**
+     * @deprecated
+     * Please use `maxAllowedTimeStep` instead.
+     */
+    get maxSumTimeStep(): number;
+    set maxSumTimeStep(value: number);
+    constructor(engine: Engine);
+    /**
+     * initialize PhysicsManager.
+     * @param physics - Physics Engine
+     */
+    initialize(physics: IPhysics): void;
+    /**
+     * Casts a ray through the Scene and returns the first hit.
+     * @param ray - The ray
+     * @returns Returns True if the ray intersects with a collider, otherwise false
+     */
+    raycast(ray: Ray): boolean;
+    /**
+     * Casts a ray through the Scene and returns the first hit.
+     * @param ray - The ray
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns True if the ray intersects with a collider, otherwise false
+     */
+    raycast(ray: Ray, outHitResult: HitResult): boolean;
+    /**
+     * Casts a ray through the Scene and returns the first hit.
+     * @param ray - The ray
+     * @param distance - The max distance the ray should check
+     * @returns Returns True if the ray intersects with a collider, otherwise false
+     */
+    raycast(ray: Ray, distance: number): boolean;
+    /**
+     * Casts a ray through the Scene and returns the first hit.
+     * @param ray - The ray
+     * @param distance - The max distance the ray should check
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns True if the ray intersects with a collider, otherwise false
+     */
+    raycast(ray: Ray, distance: number, outHitResult: HitResult): boolean;
+    /**
+     * Casts a ray through the Scene and returns the first hit.
+     * @param ray - The ray
+     * @param distance - The max distance the ray should check
+     * @param layerMask - Layer mask that is used to selectively ignore Colliders when casting
+     * @returns Returns True if the ray intersects with a collider, otherwise false
+     */
+    raycast(ray: Ray, distance: number, layerMask: Layer): boolean;
+    /**
+     * Casts a ray through the Scene and returns the first hit.
+     * @param ray - The ray
+     * @param distance - The max distance the ray should check
+     * @param layerMask - Layer mask that is used to selectively ignore Colliders when casting
+     * @param outHitResult - If true is returned, outHitResult will contain more detailed collision information
+     * @returns Returns True if the ray intersects with a collider, otherwise false.
+     */
+    raycast(ray: Ray, distance: number, layerMask: Layer, outHitResult: HitResult): boolean;
+    private _setGravity;
+}

package/types/physics/PhysicsMaterial.d.ts

@@ -0,0 +1,37 @@
+import { PhysicsMaterialCombineMode } from "./enums/PhysicsMaterialCombineMode";
+/**
+ * Material class to represent a set of surface properties.
+ */
+export declare class PhysicsMaterial {
+    private _bounciness;
+    private _dynamicFriction;
+    private _staticFriction;
+    private _bounceCombine;
+    private _frictionCombine;
+    constructor();
+    /**
+     * The coefficient of bounciness.
+     */
+    get bounciness(): number;
+    set bounciness(value: number);
+    /**
+     * The DynamicFriction value.
+     */
+    get dynamicFriction(): number;
+    set dynamicFriction(value: number);
+    /**
+     * The coefficient of static friction.
+     */
+    get staticFriction(): number;
+    set staticFriction(value: number);
+    /**
+     * The restitution combine mode.
+     */
+    get bounceCombine(): PhysicsMaterialCombineMode;
+    set bounceCombine(value: PhysicsMaterialCombineMode);
+    /**
+     * The friction combine mode.
+     */
+    get frictionCombine(): PhysicsMaterialCombineMode;
+    set frictionCombine(value: PhysicsMaterialCombineMode);
+}

package/types/physics/StaticCollider.d.ts

@@ -0,0 +1,7 @@
+import { Collider } from "./Collider";
+/**
+ * A static collider component that will not move.
+ * @remarks Mostly used for object which always stays at the same place and never moves around.
+ */
+export declare class StaticCollider extends Collider {
+}

package/types/physics/enums/ColliderShapeUpAxis.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The up axis of the collider shape.
+ */
+export declare enum ColliderShapeUpAxis {
+    /** Up axis is X. */
+    X = 0,
+    /** Up axis is Y. */
+    Y = 1,
+    /** Up axis is Z. */
+    Z = 2
+}

package/types/physics/enums/ControllerCollisionFlag.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The up axis of the collider shape.
+ */
+export declare enum ControllerCollisionFlag {
+    /** Character is colliding to the sides. */
+    Sides = 1,
+    /** Character has collision above. */
+    Up = 2,
+    /** Character has collision below. */
+    Down = 4
+}

package/types/physics/enums/ControllerNonWalkableMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The up axis of the collider shape.
+ */
+export declare enum ControllerNonWalkableMode {
+    /** Stops character from climbing up non-walkable slopes, but doesn't move it otherwise. */
+    PreventClimbing = 0,
+    /** Stops character from climbing up non-walkable slopes, and forces it to slide down those slopes. */
+    PreventClimbingAndForceSliding = 1
+}

package/types/physics/enums/HingeJointFlag.d.ts

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