@galacean/engine-core 2.0.0-alpha.2 → 2.0.0-alpha.21

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

@@ -0,0 +1,119 @@
+import { ShaderMacro } from "../../shader";
+import { ShaderProperty } from "../../shader/ShaderProperty";
+import { ParticleSimulationSpace } from "../enums/ParticleSimulationSpace";
+import { ParticleGenerator } from "../ParticleGenerator";
+import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
+import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
+/**
+ * Limit velocity over lifetime module.
+ */
+export declare class LimitVelocityOverLifetimeModule extends ParticleGeneratorModule {
+    static readonly _enabledMacro: ShaderMacro;
+    static readonly _separateAxesMacro: ShaderMacro;
+    static readonly _speedConstantModeMacro: ShaderMacro;
+    static readonly _speedCurveModeMacro: ShaderMacro;
+    static readonly _speedIsRandomMacro: ShaderMacro;
+    static readonly _dragCurveModeMacro: ShaderMacro;
+    static readonly _dragIsRandomMacro: ShaderMacro;
+    static readonly _multiplyDragBySizeMacro: ShaderMacro;
+    static readonly _multiplyDragByVelocityMacro: ShaderMacro;
+    static readonly _speedMaxConstProperty: ShaderProperty;
+    static readonly _speedMinConstProperty: ShaderProperty;
+    static readonly _speedMaxCurveProperty: ShaderProperty;
+    static readonly _speedMinCurveProperty: ShaderProperty;
+    static readonly _speedMaxConstVecProperty: ShaderProperty;
+    static readonly _speedMinConstVecProperty: ShaderProperty;
+    static readonly _speedXMaxCurveProperty: ShaderProperty;
+    static readonly _speedXMinCurveProperty: ShaderProperty;
+    static readonly _speedYMaxCurveProperty: ShaderProperty;
+    static readonly _speedYMinCurveProperty: ShaderProperty;
+    static readonly _speedZMaxCurveProperty: ShaderProperty;
+    static readonly _speedZMinCurveProperty: ShaderProperty;
+    static readonly _dampenProperty: ShaderProperty;
+    static readonly _dragConstantProperty: ShaderProperty;
+    static readonly _dragMaxCurveProperty: ShaderProperty;
+    static readonly _dragMinCurveProperty: ShaderProperty;
+    static readonly _spaceProperty: ShaderProperty;
+    private _speedMinConstantVec;
+    private _speedMaxConstantVec;
+    private _dragConstantVec;
+    private _enabledModuleMacro;
+    private _separateAxesCachedMacro;
+    private _speedModeMacro;
+    private _speedRandomMacro;
+    private _dragCurveCachedMacro;
+    private _dragRandomCachedMacro;
+    private _dragSizeMacro;
+    private _dragVelocityMacro;
+    private _separateAxes;
+    private _speedX;
+    private _speedY;
+    private _speedZ;
+    private _dampen;
+    private _drag;
+    private _multiplyDragByParticleSize;
+    private _multiplyDragByParticleVelocity;
+    private _space;
+    /**
+     * Whether to limit velocity on each axis separately.
+     */
+    get separateAxes(): boolean;
+    set separateAxes(value: boolean);
+    /**
+     * Speed limit when separateAxes is false.
+     */
+    get speed(): ParticleCompositeCurve;
+    set speed(value: ParticleCompositeCurve);
+    /**
+     * Speed limit for the x-axis (or overall limit when separateAxes is false).
+     */
+    get speedX(): ParticleCompositeCurve;
+    set speedX(value: ParticleCompositeCurve);
+    /**
+     * Speed limit for the y-axis.
+     */
+    get speedY(): ParticleCompositeCurve;
+    set speedY(value: ParticleCompositeCurve);
+    /**
+     * Speed limit for the z-axis.
+     */
+    get speedZ(): ParticleCompositeCurve;
+    set speedZ(value: ParticleCompositeCurve);
+    /**
+     * Controls how much the velocity is dampened when it exceeds the limit.
+     * @remarks Value is clamped to [0, 1]. 0 means no damping, 1 means full damping.
+     */
+    get dampen(): number;
+    set dampen(value: number);
+    /**
+     * Controls the amount of drag applied to particle velocities.
+     */
+    get drag(): ParticleCompositeCurve;
+    set drag(value: ParticleCompositeCurve);
+    /**
+     * Adjust the amount of drag based on particle sizes.
+     */
+    get multiplyDragByParticleSize(): boolean;
+    set multiplyDragByParticleSize(value: boolean);
+    /**
+     * Adjust the amount of drag based on particle speeds.
+     */
+    get multiplyDragByParticleVelocity(): boolean;
+    set multiplyDragByParticleVelocity(value: boolean);
+    /**
+     * Specifies if the velocity limits are in local space or world space.
+     * @remarks Only takes effect when 'separateAxes' is enabled.
+     */
+    get space(): ParticleSimulationSpace;
+    set space(value: ParticleSimulationSpace);
+    /**
+     * Specifies whether the module is enabled.
+     * @remarks This module requires WebGL2, On WebGL1, enabling will be silently ignored.
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    constructor(generator: ParticleGenerator);
+    private _uploadScalarSpeed;
+    private _uploadSeparateAxisSpeeds;
+    private _uploadDrag;
+}

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

@@ -23,11 +23,11 @@ export declare class MainModule implements ICustomClone {
     startDelay: ParticleCompositeCurve;
     /** A flag to enable 3D particle rotation, when disabled, only `startRotationZ` is used. */
     startRotation3D: boolean;
-    /** The initial rotation of particles around the x-axis when emitted.*/
+    /** The initial rotation of particles around the x-axis when emitted, in degrees. */
     startRotationX: ParticleCompositeCurve;
-    /** The initial rotation of particles around the y-axis when emitted. */
+    /** The initial rotation of particles around the y-axis when emitted, in degrees. */
     startRotationY: ParticleCompositeCurve;
-    /** The initial rotation of particles around the z-axis when emitted. */
+    /** The initial rotation of particles around the z-axis when emitted, in degrees. */
     startRotationZ: ParticleCompositeCurve;
     /** Makes some particles spin in the opposite direction. */
     flipRotation: number;

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

@@ -20,11 +20,11 @@ export declare class RotationOverLifetimeModule extends ParticleGeneratorModule
     static readonly _maxCurveZProperty: ShaderProperty;
     /** Specifies whether the rotation is separate on each axis, when disabled, only `rotationZ` is used. */
     separateAxes: boolean;
-    /** Rotation over lifetime for z axis. */
+    /** Rotation over lifetime for x axis, in degrees. */
     rotationX: ParticleCompositeCurve;
-    /** Rotation over lifetime for z axis. */
+    /** Rotation over lifetime for y axis, in degrees. */
     rotationY: ParticleCompositeCurve;
-    /** Rotation over lifetime for z axis. */
+    /** Rotation over lifetime for z axis, in degrees. */
     rotationZ: ParticleCompositeCurve;
     private _rotationMinConstant;
     private _rotationMaxConstant;

package/types/physics/DynamicCollider.d.ts

@@ -124,19 +124,25 @@ export declare class DynamicCollider extends Collider {
      */
     applyTorque(torque: Vector3): void;
     /**
-     * Moves kinematically controlled dynamic actors through the game world.
-     * @param position - The desired position for the kinematic actor
+     * Moves the kinematic collider to the specified position.
+     * @remarks Only available when {@link isKinematic} is true.
+     * Unlike setting the transform directly (teleport), this method affects dynamic colliders along the movement path.
+     * @param position - The desired position for the kinematic collider
      */
     move(position: Vector3): void;
     /**
-     * Moves kinematically controlled dynamic actors through the game world.
-     * @param rotation - The desired rotation for the kinematic actor
+     * Moves the kinematic collider to the specified rotation.
+     * @remarks Only available when {@link isKinematic} is true.
+     * Unlike setting the transform directly (teleport), this method affects dynamic colliders along the movement path.
+     * @param rotation - The desired rotation for the kinematic collider
      */
     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
+     * Moves the kinematic collider to the specified position and rotation.
+     * @remarks Only available when {@link isKinematic} is true.
+     * Unlike setting the transform directly (teleport), this method affects dynamic colliders along the movement path.
+     * @param position - The desired position for the kinematic collider
+     * @param rotation - The desired rotation for the kinematic collider
      */
     move(position: Vector3, rotation: Quaternion): void;
     /**

package/types/physics/PhysicsScene.d.ts

@@ -9,18 +9,13 @@ import { ColliderShape } from "./shape";
 export declare class PhysicsScene {
     private static _collision;
     private static _identityQuaternion;
+    private static _scriptIndexSetter;
     private _scene;
     private _restTime;
     private _fixedTimeStep;
     private _colliders;
     private _gravity;
     private _nativePhysicsScene;
-    private _onContactEnter;
-    private _onContactExit;
-    private _onContactStay;
-    private _onTriggerEnter;
-    private _onTriggerExit;
-    private _onTriggerStay;
     /**
      * The gravity of physics scene.
      */
@@ -269,6 +264,7 @@ export declare class PhysicsScene {
      * @returns The collider shapes overlapping with the capsule
      */
     overlapCapsuleAll(center: Vector3, radius: number, height: number, orientation?: Quaternion, layerMask?: Layer, shapes?: ColliderShape[]): ColliderShape[];
+    private _dispatchEvents;
     private _setGravity;
     private _createPreFilter;
     private _createHitCallback;

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

@@ -0,0 +1,9 @@
+/**
+ * Cooking flags for {@link MeshColliderShape}.
+ */
+export declare enum MeshColliderShapeCookingFlag {
+    /** Remove degenerate triangles and coincident vertices. */
+    Cleaning = 1,
+    /** Weld vertices that are close to each other. Requires {@link MeshColliderShapeCookingFlag.Cleaning} to be enabled. */
+    VertexWelding = 2
+}

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

@@ -1,3 +1,4 @@
+export * from "./MeshColliderShapeCookingFlag";
 export * from "./PhysicsMaterialCombineMode";
 export * from "./ColliderShapeUpAxis";
 export * from "./ControllerCollisionFlag";

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

@@ -1,59 +1,45 @@
-import { Mesh } from "../../graphic/Mesh";
+import { ModelMesh } from "../../mesh/ModelMesh";
+import { Vector3 } from "@galacean/engine-math";
+import { MeshColliderShapeCookingFlag } from "../enums/MeshColliderShapeCookingFlag";
 import { ColliderShape } from "./ColliderShape";
 /**
- * Physical collider shape for mesh.
- * @remarks
- * - Triangle mesh (isConvex=false) works with StaticCollider or kinematic DynamicCollider
- * - Convex mesh (isConvex=true) works with both StaticCollider and DynamicCollider
- * @see https://nvidia-omniverse.github.io/PhysX/physx/5.4.1/docs/Geometry.html#triangle-meshes
+ * Collider shape based on mesh geometry, supporting both convex hull and triangle mesh modes.
  */
 export declare class MeshColliderShape extends ColliderShape {
+    private _mesh;
     private _isConvex;
-    private _vertices;
+    private _positions;
     private _indices;
-    private _doubleSided;
-    private _tightBounds;
-    private _indicesU16Cache;
+    private _cookingFlags;
+    private _isShapeAttached;
+    /**
+     * Cooking flags for this mesh collider shape.
+     */
+    get cookingFlags(): MeshColliderShapeCookingFlag;
+    set cookingFlags(value: MeshColliderShapeCookingFlag);
     /**
      * Whether to use convex mesh mode.
      * @remarks
-     * - Convex mesh: Works with all collider types, PhysX auto-computes convex hull
-     * - Triangle mesh: Works with StaticCollider or kinematic DynamicCollider, requires indices
-     * - After changing this property, you must call {@link setMesh} or {@link setMeshData} again to apply the change
+     * - When true, generates a convex hull from the mesh vertices. Works with all collider types.
+     * - When false, uses the original triangle mesh. Only works with StaticCollider or kinematic DynamicCollider, and the mesh must have indices.
      */
     get isConvex(): boolean;
     set isConvex(value: boolean);
     /**
-     * Whether the triangle mesh should be double-sided for collision detection.
-     * @remarks Only applies to triangle mesh (non-convex).
-     */
-    get doubleSided(): boolean;
-    set doubleSided(value: boolean);
-    /**
-     * Whether to use tight bounds for convex mesh.
-     * @remarks Only applies to convex mesh.
-     */
-    get tightBounds(): boolean;
-    set tightBounds(value: boolean);
-    /**
-     * Create a MeshColliderShape.
-     * @param isConvex - Whether to use convex mesh mode (default: false)
-     */
-    constructor(isConvex?: boolean);
-    /**
-     * Set mesh data directly from arrays.
-     * @param vertices - Vertex positions as Float32Array (x, y, z per vertex)
-     * @param indices - Triangle indices (required for triangle mesh, optional for convex)
+     * The mesh used for collision detection.
+     * @remarks The mesh must have accessible data (not released after upload).
      */
-    setMeshData(vertices: Float32Array, indices?: Uint16Array | Uint32Array): void;
+    get mesh(): ModelMesh;
+    set mesh(value: ModelMesh);
     /**
-     * Set mesh data from a Mesh object.
-     * @param mesh - The mesh to extract vertex and index data from
-     * @remarks The mesh must have accessible data (not released after upload)
+     * {@inheritDoc ColliderShape.getClosestPoint}
      */
-    setMesh(mesh: Mesh): void;
-    protected _syncNative(): void;
+    getClosestPoint(point: Vector3, outClosestPoint: Vector3): number;
+    private _clearMeshData;
+    private _destroyNativeShape;
     private _extractMeshData;
-    private _extractIndices;
-    private _updateNativeMesh;
+    private _updateNativeShapeData;
+    private _detachFromCollider;
+    private _attachToCollider;
+    private _createNativeShape;
 }

package/types/renderingHardwareInterface/IPlatformBuffer.d.ts

@@ -3,5 +3,6 @@ export interface IPlatformBuffer {
     bind(): void;
     setData(byteLength: number, data: ArrayBuffer | ArrayBufferView, bufferByteOffset?: number, dataOffset?: number, dataLength?: number, options?: SetDataOptions): void;
     getData(data: ArrayBufferView, bufferByteOffset?: number, dataOffset?: number, dataLength?: number): void;
+    copyFromBuffer(srcBuffer: IPlatformBuffer, srcByteOffset: number, dstByteOffset: number, byteLength: number): void;
     destroy(): void;
 }

package/types/renderingHardwareInterface/IPlatformTransformFeedback.d.ts

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

package/types/renderingHardwareInterface/IPlatformTransformFeedbackPrimitive.d.ts

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

package/types/renderingHardwareInterface/index.d.ts

@@ -4,3 +4,5 @@ export type { IPlatformTexture } from "./IPlatformTexture";
 export type { IPlatformTexture2D } from "./IPlatformTexture2D";
 export type { IPlatformTexture2DArray } from "./IPlatformTexture2DArray";
 export type { IPlatformTextureCube } from "./IPlatformTextureCube";
+export type { IPlatformTransformFeedback } from "./IPlatformTransformFeedback";
+export type { IPlatformTransformFeedbackPrimitive } from "./IPlatformTransformFeedbackPrimitive";

package/types/shader/ShaderPass.d.ts

@@ -3,7 +3,6 @@ import { ShaderPart } from "./ShaderPart";
  * Shader pass containing vertex and fragment source.
  */
 export declare class ShaderPass extends ShaderPart {
-    private static _shaderPassCounter;
     private _vertexSource;
     private _fragmentSource;
     /**
@@ -22,4 +21,5 @@ export declare class ShaderPass extends ShaderPart {
      */
     constructor(vertexSource: string, fragmentSource: string, tags?: Record<string, number | string | boolean>);
     private _getCanonicalShaderProgram;
+    private _getShaderLabProgram;
 }

package/types/shaderlib/ShaderLib.d.ts

@@ -6,6 +6,8 @@ export declare const ShaderLib: {
     color_over_lifetime_module: string;
     texture_sheet_animation_module: string;
     force_over_lifetime_module: string;
+    limit_velocity_over_lifetime_module: string;
+    particle_feedback_simulation: string;
     sphere_billboard: string;
     stretched_billboard: string;
     vertical_billboard: string;

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

@@ -6,6 +6,8 @@ declare const _default: {
     color_over_lifetime_module: string;
     texture_sheet_animation_module: string;
     force_over_lifetime_module: string;
+    limit_velocity_over_lifetime_module: string;
+    particle_feedback_simulation: string;
     sphere_billboard: string;
     stretched_billboard: string;
     vertical_billboard: string;

package/types/sky/SkyBoxMaterial.d.ts

@@ -10,14 +10,7 @@ export declare class SkyBoxMaterial extends Material {
     private static _textureCubeProp;
     private static _rotationProp;
     private static _exposureProp;
-    private static _decodeSkyRGBMMacro;
-    private _textureDecodeRGBM;
     private _tintColor;
-    /**
-     * Whether to decode texture with RGBM format.
-     */
-    get textureDecodeRGBM(): boolean;
-    set textureDecodeRGBM(value: boolean);
     /**
      * Texture of the sky box material.
      */

package/types/texture/RenderTarget.d.ts

@@ -12,6 +12,7 @@ export declare class RenderTarget extends GraphicsResource {
     private _height;
     private _colorTextures;
     private _depthTexture;
+    private _memorySize;
     /**
      * Whether to automatically generate multi-level textures.
      */
@@ -25,6 +26,10 @@ export declare class RenderTarget extends GraphicsResource {
      * Render target height.
      */
     get height(): number;
+    /**
+     * Render color textures.
+     */
+    get colorTextures(): ReadonlyArray<Texture>;
     /**
      * Render color texture count.
      */

package/types/trail/TrailRenderer.d.ts

@@ -1,4 +1,4 @@
-import { BoundingBox } from "@galacean/engine-math";
+import { BoundingBox, Vector2 } from "@galacean/engine-math";
 import { RenderContext } from "../RenderPipeline/RenderContext";
 import { Renderer } from "../Renderer";
 import { ParticleCurve } from "../particle/modules/ParticleCurve";
@@ -31,6 +31,7 @@ export declare class TrailRenderer extends Renderer {
     /** The gradient describing the trail color from start to end. */
     colorGradient: ParticleGradient;
     private _trailParams;
+    private _textureScale;
     private _distanceParams;
     private _curveMaxTime;
     private _time;
@@ -55,21 +56,17 @@ export declare class TrailRenderer extends Renderer {
      */
     get time(): number;
     set time(value: number);
-    /**
-     * The width of the trail.
-     */
-    get width(): number;
-    set width(value: number);
     /**
      * The texture mapping mode for the trail.
      */
     get textureMode(): TrailTextureMode;
     set textureMode(value: TrailTextureMode);
     /**
-     * The texture scale when using Tile texture mode.
+     * Scale of the UV coordinates.
+     * x scales the coordinate along the trail, y scales the coordinate across the trail.
      */
-    get textureScale(): number;
-    set textureScale(value: number);
+    get textureScale(): Vector2;
+    set textureScale(value: Vector2);
     /**
      * Clear all trail points.
      */
@@ -89,4 +86,5 @@ export declare class TrailRenderer extends Renderer {
     private _getActivePointCount;
     private _addActivePointsToVertexBuffer;
     private _addSubRenderElement;
+    private _onTextureScaleChanged;
 }