Add support for more features in the particules to NPE converter

packages/dev/core/src/Particles/Node/Blocks/systemBlock.ts

@@ -12,6 +12,8 @@ import { _TriggerSubEmitter } from "./Triggers/triggerTools";
  * Block used to get a system of particles
  */
 export class SystemBlock extends NodeParticleBlock {
+    private static _IdCounter = 0;
+
     /**
      * Gets or sets the blend mode for the particle system
      */
@@ -58,6 +60,9 @@ export class SystemBlock extends NodeParticleBlock {
     @editableInPropertyPage("Do no start", PropertyTypeForEdition.Boolean, "ADVANCED", { embedded: true, notifiers: { rebuild: true } })
     public doNoStart = false;
 
+    /** @internal */
+    public _internalId = SystemBlock._IdCounter++;
+
     /**
      * Create a new SystemBlock
      * @param name defines the block name

packages/dev/core/src/Particles/Node/nodeParticleSystemSet.helper.ts

@@ -32,6 +32,8 @@ function _CreateAndConnectInput(connectionPoint: NodeParticleConnectionPoint, na
 async function _ExtractDatafromParticleSystemAsync(particleSystem: ParticleSystem, target: NodeParticleSystemSet) {
     // Main system
     const system = new SystemBlock(particleSystem.name);
+    system.capacity = particleSystem.getCapacity();
+    system.emitRate = particleSystem.emitRate;
 
     // Create particle
     const createParticleBlock = new CreateParticleBlock("Create particle");
@@ -107,11 +109,37 @@ async function _ExtractDatafromParticleSystemAsync(particleSystem: ParticleSyste
     const color1Block = new ParticleInputBlock("Color1");
     color1Block.value = particleSystem.color2;
 
-    const randomBlock = new ParticleRandomBlock("Random");
-    color0Block.output.connectTo(randomBlock.min);
-    color1Block.output.connectTo(randomBlock.max);
+    const randomColorBlock = new ParticleRandomBlock("Random Color");
+    color0Block.output.connectTo(randomColorBlock.min);
+    color1Block.output.connectTo(randomColorBlock.max);
 
-    randomBlock.output.connectTo(createParticleBlock.color);
+    randomColorBlock.output.connectTo(createParticleBlock.color);
+
+    // Emit power
+    const minEmitPowerBlock = new ParticleInputBlock("Min Emit Power");
+    minEmitPowerBlock.value = particleSystem.minEmitPower;
+
+    const maxEmitPowerBlock = new ParticleInputBlock("Max Emit Power");
+    maxEmitPowerBlock.value = particleSystem.maxEmitPower;
+
+    const randomEmitPowerBlock = new ParticleRandomBlock("Random Emit Power");
+    minEmitPowerBlock.output.connectTo(randomEmitPowerBlock.min);
+    maxEmitPowerBlock.output.connectTo(randomEmitPowerBlock.max);
+
+    randomEmitPowerBlock.output.connectTo(createParticleBlock.emitPower);
+
+    // Lifetime
+    const minLifetimeBlock = new ParticleInputBlock("Min Lifetime");
+    minLifetimeBlock.value = particleSystem.minLifeTime;
+
+    const maxLifetimeBlock = new ParticleInputBlock("Max Lifetime");
+    maxLifetimeBlock.value = particleSystem.maxLifeTime;
+
+    const randomLifetimeBlock = new ParticleRandomBlock("Random Lifetime");
+    minLifetimeBlock.output.connectTo(randomLifetimeBlock.min);
+    maxLifetimeBlock.output.connectTo(randomLifetimeBlock.max);
+
+    randomLifetimeBlock.output.connectTo(createParticleBlock.lifeTime);
 
     // Texture
     const textureBlock = new ParticleTextureSourceBlock("Texture");
@@ -141,7 +169,7 @@ async function _ExtractDatafromParticleSystemAsync(particleSystem: ParticleSyste
  * @param name The name of the node particle system set.
  * @param particleSystems The particle systems to convert.
  * @returns The converted node particle system set or null if conversion failed.
- * #0K3AQ2#3625
+ * #0K3AQ2#3627
  */
 export async function ConvertToNodeParticleSystemSetAsync(name: string, particleSystems: ParticleSystem[]): Promise<Nullable<NodeParticleSystemSet>> {
     if (!particleSystems || !particleSystems.length) {

packages/dev/core/src/Particles/Node/nodeParticleSystemSet.ts

@@ -270,6 +270,7 @@ export class NodeParticleSystemSet {
 
                 const system = block.createSystem(state);
                 system._source = this;
+                system._blockReference = block._internalId;
 
                 // Errors
                 state.emitErrors();

packages/dev/core/src/Particles/particleSystem.ts

@@ -109,6 +109,9 @@ export class ParticleSystem extends ThinParticleSystem {
     /** @internal */
     public _source: Nullable<NodeParticleSystemSet> = null;
 
+    /** @internal */
+    public _blockReference: number = 0;
+
     /**
      * Gets the NodeParticleSystemSet that this particle system belongs to.
      */

packages/tools/nodeParticleEditor/src/components/preview/previewManager.ts

@@ -10,10 +10,13 @@ import { SceneLoaderFlags } from "core/Loading/sceneLoaderFlags";
 import type { NodeParticleSystemSet } from "core/Particles/Node/nodeParticleSystemSet";
 import { LogEntry } from "../log/logComponent";
 import { GridMaterial } from "materials/grid/gridMaterial";
-import { MeshBuilder } from "core/Meshes";
+import { MeshBuilder } from "core/Meshes/meshBuilder";
+import type { AbstractMesh } from "core/Meshes/abstractMesh";
 import { SceneInstrumentation } from "core/Instrumentation/sceneInstrumentation";
 import type { ThinParticleSystem } from "core/Particles/thinParticleSystem";
 import type { ParticleSystemSet } from "core/Particles/particleSystemSet";
+import { EngineStore } from "core/Engines";
+import type { ParticleSystem } from "core/Particles";
 
 export class PreviewManager {
     private _nodeParticleSystemSet: NodeParticleSystemSet;
@@ -128,6 +131,45 @@ export class PreviewManager {
             // Ignore the error
             this._globalState.onIsLoadingChanged.notifyObservers(false);
         }
+
+        // Synchronize with main
+        for (const engine of EngineStore.Instances) {
+            for (const scene of engine.scenes) {
+                if (scene === this._scene) {
+                    continue;
+                }
+
+                void this._reconnectEmittersAsync(scene);
+            }
+        }
+    }
+
+    private async _reconnectEmittersAsync(scene: Scene) {
+        const map = new Map<number, Nullable<AbstractMesh | Vector3>>();
+
+        for (const ps of scene.particleSystems) {
+            const particleSystem = ps as ParticleSystem;
+            const source = particleSystem.source;
+            if (source === this._nodeParticleSystemSet) {
+                // Keep track of particle system reference and emitter
+                const reference = particleSystem._blockReference;
+                const emitter = particleSystem.emitter;
+
+                particleSystem.dispose();
+
+                map.set(reference, emitter);
+            }
+        }
+
+        const newSet = await this._nodeParticleSystemSet.buildAsync(scene);
+        for (const [reference, emitter] of map) {
+            const particleSystem = (newSet.systems as ParticleSystem[]).find((ps) => ps._blockReference === reference);
+            if (particleSystem) {
+                particleSystem.emitter = emitter;
+            }
+        }
+
+        newSet.start();
     }
 
     public dispose() {