particle support limit velocity over lifetime

e2e/case/particleRenderer-limitVelocity.ts

@@ -0,0 +1,148 @@
+/**
+ * @title Particle Limit Velocity Over Lifetime
+ * @category Particle
+ */
+import {
+  AssetType,
+  BlendMode,
+  Burst,
+  Camera,
+  Color,
+  Engine,
+  Entity,
+  SphereShape,
+  Logger,
+  ParticleCompositeCurve,
+  ParticleCurveMode,
+  ParticleGradientMode,
+  ParticleMaterial,
+  ParticleRenderer,
+  ParticleSimulationSpace,
+  PostProcess,
+  BloomEffect,
+  TonemappingEffect,
+  Texture2D,
+  WebGLEngine
+} from "@galacean/engine";
+import { initScreenshot, updateForE2E } from "./.mockForE2E";
+
+// Create engine
+WebGLEngine.create({
+  canvas: "canvas"
+}).then((engine) => {
+  Logger.enable();
+  engine.canvas.resizeByClientSize();
+
+  const scene = engine.sceneManager.activeScene;
+  const rootEntity = scene.createRootEntity();
+  scene.background.solidColor = new Color(0, 0, 0, 1);
+
+  // Camera
+  const cameraEntity = rootEntity.createChild("camera");
+  cameraEntity.transform.setPosition(2, 1.43, 30);
+  cameraEntity.transform.setRotation(0, 0, 0);
+  const camera = cameraEntity.addComponent(Camera);
+  camera.fieldOfView = 60;
+  camera.enableHDR = true;
+  camera.enablePostProcess = true;
+
+  // Post process
+  const postProcess = rootEntity.addComponent(PostProcess);
+  const bloom = postProcess.addEffect(BloomEffect);
+  bloom.intensity.value = 1;
+  bloom.threshold.value = 0.8;
+  postProcess.addEffect(TonemappingEffect);
+
+  engine.run();
+
+  engine.resourceManager
+    .load({
+      url: "https://mdn.alipayobjects.com/huamei_b4l2if/afts/img/A*JPsCSK5LtYkAAAAAAAAAAAAADil6AQ/original",
+      type: AssetType.Texture2D
+    })
+    .then((texture) => {
+      createScalarLimitParticle(engine, rootEntity, <Texture2D>texture);
+    });
+});
+
+function createScalarLimitParticle(engine: Engine, rootEntity: Entity, texture: Texture2D): void {
+  const particleEntity = rootEntity.createChild("ScalarLimit");
+  particleEntity.transform.setPosition(2.006557, 1.43, 12.35);
+
+  const particleRenderer = particleEntity.addComponent(ParticleRenderer);
+
+  const material = new ParticleMaterial(engine);
+  material.baseColor = new Color(0.2, 0.6, 1.0, 1.0);
+  material.blendMode = BlendMode.Additive;
+  material.baseTexture = texture;
+  particleRenderer.setMaterial(material);
+
+  const generator = particleRenderer.generator;
+  generator.useAutoRandomSeed = false;
+
+  const { main, emission, limitVelocityOverLifetime, colorOverLifetime, velocityOverLifetime } = generator;
+
+  // Main module
+  main.duration = 2;
+  main.isLoop = true;
+  main.startDelay.constant = 0;
+  main.startLifetime.constantMin = 0.6;
+  main.startLifetime.constantMax = 1;
+  main.startLifetime.mode = ParticleCurveMode.TwoConstants;
+  main.startSpeed.constantMin = 20;
+  main.startSpeed.constantMax = 40;
+  main.startSpeed.mode = ParticleCurveMode.TwoConstants;
+  main.startSize.constantMin = 0.05;
+  main.startSize.constantMax = 0.15;
+  main.startSize.mode = ParticleCurveMode.TwoConstants;
+  main.startColor.constantMin.set(280 / 255, 670 / 255, 2550 / 255, 1);
+  main.startColor.constantMax.set(1130 / 255, 740 / 255, 2550 / 255, 1);
+  main.startColor.mode = ParticleGradientMode.TwoConstants;
+  main.gravityModifier.constant = 0;
+  main.simulationSpace = ParticleSimulationSpace.Local;
+  main.maxParticles = 100;
+
+  // Emission
+  emission.rateOverTime.constant = 0;
+  emission.addBurst(new Burst(0, new ParticleCompositeCurve(10, 30)));
+
+  const sphereShape = new SphereShape();
+  sphereShape.radius = 0.8;
+  emission.shape = sphereShape;
+
+  // Color over lifetime: fade in then fade out
+  colorOverLifetime.enabled = true;
+  colorOverLifetime.color.mode = ParticleGradientMode.Gradient;
+  const gradient = colorOverLifetime.color.gradient;
+  gradient.alphaKeys[0].alpha = 0;
+  gradient.alphaKeys[1].alpha = 0;
+  gradient.addAlphaKey(0.2, 1.0);
+  gradient.addAlphaKey(0.8, 1.0);
+
+  // Velocity over lifetime (delayed activation)
+  setTimeout(() => {
+    velocityOverLifetime.enabled = true;
+    velocityOverLifetime.velocityX.constant = 1;
+    velocityOverLifetime.velocityY.constant = 20;
+    velocityOverLifetime.velocityZ.constant = 1;
+    console.log("s");
+  }, 3000);
+
+  // Limit velocity over lifetime
+  limitVelocityOverLifetime.enabled = true;
+  limitVelocityOverLifetime.separateAxes = true;
+  limitVelocityOverLifetime.limitX = new ParticleCompositeCurve(1);
+  limitVelocityOverLifetime.limitY = new ParticleCompositeCurve(1);
+  limitVelocityOverLifetime.limitZ = new ParticleCompositeCurve(0);
+  //   limitVelocityOverLifetime.limit = new ParticleCompositeCurve(1);
+  limitVelocityOverLifetime.space = ParticleSimulationSpace.World;
+  limitVelocityOverLifetime.dampen = 0.25;
+  limitVelocityOverLifetime.drag = new ParticleCompositeCurve(0.0);
+  limitVelocityOverLifetime.multiplyDragByParticleSize = true;
+  limitVelocityOverLifetime.multiplyDragByParticleVelocity = true;
+
+  //   limitVelocityOverLifetime.enabled = true;
+  // limitVelocityOverLifetime.separateAxes = false;
+  // limitVelocityOverLifetime.limit = new ParticleCompositeCurve(0);
+  // limitVelocityOverLifetime.dampen = 1;
+}

e2e/config.ts

@@ -335,6 +335,12 @@ export const E2E_CONFIG = {
       threshold: 0,
       diffPercentage: 0.1630209
     },
+    limitVelocityOverLifetime: {
+      category: "Particle",
+      caseFileName: "particleRenderer-limitVelocity",
+      threshold: 0,
+      diffPercentage: 0.15
+    },
     textureSheetAnimation: {
       category: "Particle",
       caseFileName: "particleRenderer-textureSheetAnimation",

packages/core/src/graphic/Buffer.ts

@@ -13,11 +13,12 @@ import { SetDataOptions } from "./enums/SetDataOptions";
 export class Buffer extends GraphicsResource {
   /** @internal */
   _dataUpdateManager: UpdateFlagManager = new UpdateFlagManager();
+  /** @internal */
+  _platformBuffer: IPlatformBuffer;
 
   private _type: BufferBindFlag;
   private _byteLength: number;
   private _bufferUsage: BufferUsage;
-  private _platformBuffer: IPlatformBuffer;
   private _readable: boolean;
   private _data: Uint8Array;
 

packages/core/src/graphic/TransformFeedback.ts

@@ -0,0 +1,76 @@
+import { GraphicsResource } from "../asset/GraphicsResource";
+import { Engine } from "../Engine";
+import { IPlatformTransformFeedback } from "../renderingHardwareInterface";
+import { Buffer } from "./Buffer";
+import { MeshTopology } from "./enums/MeshTopology";
+
+/**
+ * Transform Feedback object for GPU-based data capture.
+ * @internal
+ */
+export class TransformFeedback extends GraphicsResource {
+  /** @internal */
+  _platformTransformFeedback: IPlatformTransformFeedback;
+
+  constructor(engine: Engine) {
+    super(engine);
+    this._platformTransformFeedback = engine._hardwareRenderer.createPlatformTransformFeedback();
+  }
+
+  /**
+   * Bind this Transform Feedback object as active.
+   */
+  bind(): void {
+    this._platformTransformFeedback.bind();
+  }
+
+  /**
+   * Bind a buffer range as output at the given index.
+   * @param index - Output binding point index (corresponds to varying index in shader)
+   * @param buffer - Output buffer to capture data into
+   * @param byteOffset - Starting byte offset in the buffer
+   * @param byteSize - Size in bytes of the capture range
+   */
+  bindBufferRange(index: number, buffer: Buffer, byteOffset: number, byteSize: number): void {
+    this._platformTransformFeedback.bindBufferRange(index, buffer._platformBuffer, byteOffset, byteSize);
+  }
+
+  /**
+   * Begin a Transform Feedback pass.
+   * @param primitiveMode - Primitive topology mode
+   */
+  begin(primitiveMode: MeshTopology): void {
+    this._platformTransformFeedback.begin(primitiveMode);
+  }
+
+  /**
+   * End the current Transform Feedback pass.
+   */
+  end(): void {
+    this._platformTransformFeedback.end();
+  }
+
+  /**
+   * Unbind the output buffer at the given index from the Transform Feedback target.
+   * @param index - Output binding point index
+   */
+  unbindBuffer(index: number): void {
+    this._platformTransformFeedback.unbindBuffer(index);
+  }
+
+  /**
+   * Unbind this Transform Feedback object.
+   */
+  unbind(): void {
+    this._platformTransformFeedback.unbind();
+  }
+
+  override _rebuild(): void {
+    this._platformTransformFeedback = this._engine._hardwareRenderer.createPlatformTransformFeedback();
+  }
+
+  protected override _onDestroy(): void {
+    super._onDestroy();
+    this._platformTransformFeedback.destroy();
+  }
+}

packages/core/src/graphic/TransformFeedbackPrimitive.ts

@@ -0,0 +1,143 @@
+import { Engine } from "../Engine";
+import { IPlatformTransformFeedbackPrimitive } from "../renderingHardwareInterface";
+import { ShaderProgram } from "../shader/ShaderProgram";
+import { Buffer } from "./Buffer";
+import { BufferBindFlag } from "./enums/BufferBindFlag";
+import { BufferUsage } from "./enums/BufferUsage";
+import { MeshTopology } from "./enums/MeshTopology";
+import { TransformFeedback } from "./TransformFeedback";
+import { VertexBufferBinding } from "./VertexBufferBinding";
+import { VertexElement } from "./VertexElement";
+
+/**
+ * @internal
+ * Primitive for Transform Feedback simulation with read/write buffer swapping.
+ */
+export class TransformFeedbackPrimitive {
+  /** @internal */
+  _platformPrimitive: IPlatformTransformFeedbackPrimitive;
+
+  private _engine: Engine;
+  private _transformFeedback: TransformFeedback;
+  private _bindingA: VertexBufferBinding;
+  private _bindingB: VertexBufferBinding;
+  private _byteStride: number;
+  private _readIsA = true;
+
+  /**
+   * The current read buffer binding.
+   */
+  get readBinding(): VertexBufferBinding {
+    return this._readIsA ? this._bindingA : this._bindingB;
+  }
+
+  /**
+   * The current write buffer binding.
+   */
+  get writeBinding(): VertexBufferBinding {
+    return this._readIsA ? this._bindingB : this._bindingA;
+  }
+
+  /**
+   * @param engine - Engine instance
+   * @param byteStride - Bytes per vertex
+   */
+  constructor(engine: Engine, byteStride: number) {
+    this._engine = engine;
+    this._byteStride = byteStride;
+    this._transformFeedback = new TransformFeedback(engine);
+    this._transformFeedback.isGCIgnored = true;
+    this._platformPrimitive = engine._hardwareRenderer.createPlatformTransformFeedbackPrimitive();
+  }
+
+  /**
+   * Resize read and write buffers.
+   * @param vertexCount - Number of vertices to allocate
+   */
+  resize(vertexCount: number): void {
+    this._bindingA?.buffer.destroy();
+    this._bindingB?.buffer.destroy();
+
+    const byteLength = this._byteStride * vertexCount;
+    const bufferA = new Buffer(this._engine, BufferBindFlag.VertexBuffer, byteLength, BufferUsage.Dynamic, false);
+    bufferA.isGCIgnored = true;
+    const bufferB = new Buffer(this._engine, BufferBindFlag.VertexBuffer, byteLength, BufferUsage.Dynamic, false);
+    bufferB.isGCIgnored = true;
+
+    this._bindingA = new VertexBufferBinding(bufferA, this._byteStride);
+    this._bindingB = new VertexBufferBinding(bufferB, this._byteStride);
+    this._readIsA = true;
+    this._platformPrimitive.invalidate();
+  }
+
+  /**
+   * Update vertex layout, only rebuilds when program changes.
+   * @param program - Shader program for attribute locations
+   * @param feedbackElements - Vertex elements describing the read/write buffer
+   * @param inputBinding - Additional input buffer binding
+   * @param inputElements - Vertex elements describing the input buffer
+   */
+  updateVertexLayout(
+    program: ShaderProgram,
+    feedbackElements: VertexElement[],
+    inputBinding: VertexBufferBinding,
+    inputElements: VertexElement[]
+  ): void {
+    this._platformPrimitive.updateVertexLayout(
+      program,
+      this._bindingA,
+      this._bindingB,
+      feedbackElements,
+      inputBinding,
+      inputElements
+    );
+  }
+
+  /**
+   * Bind state before issuing draw calls.
+   */
+  beginDraw(): void {
+    this._engine._hardwareRenderer.enableRasterizerDiscard();
+    this._transformFeedback.bind();
+    this._platformPrimitive.bind(this._readIsA);
+  }
+
+  /**
+   * Issue a draw call for a vertex range, capturing output to the write buffer.
+   * @param mode - Primitive topology
+   * @param first - First vertex index
+   * @param count - Number of vertices
+   */
+  draw(mode: MeshTopology, first: number, count: number): void {
+    const transformFeedback = this._transformFeedback;
+    transformFeedback.bindBufferRange(0, this.writeBinding.buffer, first * this._byteStride, count * this._byteStride);
+    transformFeedback.begin(mode);
+    this._platformPrimitive.draw(mode, first, count);
+    transformFeedback.end();
+  }
+
+  /**
+   * Unbind state after draw calls.
+   */
+  endDraw(): void {
+    this._platformPrimitive.unbind();
+    this._transformFeedback.unbindBuffer(0);
+    this._transformFeedback.unbind();
+    this._engine._hardwareRenderer.disableRasterizerDiscard();
+    this._engine._hardwareRenderer.invalidateShaderProgramState();
+  }
+
+  /**
+   * Swap read and write buffers.
+   */
+  swap(): void {
+    this._readIsA = !this._readIsA;
+  }
+
+  destroy(): void {
+    this._platformPrimitive?.destroy();
+    this._bindingA?.buffer.destroy();
+    this._bindingB?.buffer.destroy();
+    this._transformFeedback?.destroy();
+  }
+}