Add Solid Particle System (SPS) Support to Node Particle Editor

packages/dev/core/src/Decorators/nodeDecorator.ts

@@ -21,14 +21,14 @@ export const enum PropertyTypeForEdition {
     Color3,
     /** property is a Color4 */
     Color4,
+    /** property is a string */
+    String,
     /** property (int) should be edited as a combo box with a list of sampling modes */
     SamplingMode,
     /** property (int) should be edited as a combo box with a list of texture formats */
     TextureFormat,
     /** property (int) should be edited as a combo box with a list of texture types */
     TextureType,
-    /** property is a string */
-    String,
     /** property is a matrix */
     Matrix,
     /** property is a viewport */

packages/dev/core/src/Particles/Node/Blocks/SolidParticle/ISolidParticleData.ts

@@ -0,0 +1,39 @@
+import type { Vector3 } from "core/Maths/math.vector";
+import type { Color4 } from "core/Maths/math.color";
+import type { Material } from "core/Materials/material";
+import type { VertexData } from "core/Meshes/mesh.vertexData";
+
+/**
+ *  Interface for solid particle mesh source data
+ */
+export interface ISolidParticleMeshSourceData {
+    customMeshName?: string;
+    vertexData?: VertexData;
+}
+
+/**
+ * Interface for solid particle update block data
+ */
+export interface ISolidParticleUpdateData {
+    position?: () => Vector3;
+    velocity?: () => Vector3;
+    color?: () => Color4;
+    scaling?: () => Vector3;
+    rotation?: () => Vector3;
+}
+
+/**
+ * Interface for solid particle create block data
+ */
+export interface ISolidParticleInitData {
+    meshData: ISolidParticleMeshSourceData | null;
+    count: number;
+    material?: Material;
+    position?: () => Vector3;
+    velocity?: () => Vector3;
+    color?: () => Color4;
+    scaling?: () => Vector3;
+    rotation?: () => Vector3;
+    lifeTime?: () => number;
+    updateBlock?: ISolidParticleUpdateData | null;
+}

packages/dev/core/src/Particles/Node/Blocks/SolidParticle/createSolidParticleBlock.ts

@@ -0,0 +1,233 @@
+import { RegisterClass } from "../../../../Misc/typeStore";
+import { NodeParticleBlockConnectionPointTypes } from "../../Enums/nodeParticleBlockConnectionPointTypes";
+import { NodeParticleBlock } from "../../nodeParticleBlock";
+import type { NodeParticleConnectionPoint } from "../../nodeParticleBlockConnectionPoint";
+import type { NodeParticleBuildState } from "../../nodeParticleBuildState";
+import { SolidParticleSystem } from "core/Particles/solidParticleSystem";
+import type { ISolidParticleInitData } from "./ISolidParticleData";
+import { Mesh } from "core/Meshes/mesh";
+import type { SolidParticle } from "../../../solidParticle";
+import type { Observer } from "core/Misc/observable";
+
+/**
+ * Block used to create SolidParticleSystem and collect all Create blocks
+ */
+export class CreateSolidParticleBlock extends NodeParticleBlock {
+    private _connectionObservers = new Map<number, Observer<NodeParticleConnectionPoint>>();
+    private _disconnectionObservers = new Map<number, Observer<NodeParticleConnectionPoint>>();
+
+    public constructor(name: string) {
+        super(name);
+        this.registerInput(`config-${this._entryCount - 1}`, NodeParticleBlockConnectionPointTypes.SolidParticleConfig);
+        this.registerOutput("solidParticle", NodeParticleBlockConnectionPointTypes.SolidParticle);
+
+        this._manageExtendedInputs(0);
+    }
+
+    public override getClassName() {
+        return "CreateSolidParticleBlock";
+    }
+
+    private _entryCount = 1;
+
+    private _extend() {
+        this._entryCount++;
+        this.registerInput(`config-${this._entryCount - 1}`, NodeParticleBlockConnectionPointTypes.SolidParticleConfig, true);
+        this._manageExtendedInputs(this._entryCount - 1);
+    }
+
+    private _shrink() {
+        if (this._entryCount > 1) {
+            this._unmanageExtendedInputs(this._entryCount - 1);
+            this._entryCount--;
+            this.unregisterInput(`config-${this._entryCount}`);
+        }
+    }
+
+    private _manageExtendedInputs(index: number) {
+        const connectionObserver = this._inputs[index].onConnectionObservable.add(() => {
+            if (this._entryCount - 1 > index) {
+                return;
+            }
+            this._extend();
+        });
+
+        const disconnectionObserver = this._inputs[index].onDisconnectionObservable.add(() => {
+            if (this._entryCount - 1 > index) {
+                return;
+            }
+            this._shrink();
+        });
+
+        // Store observers for later removal
+        this._connectionObservers.set(index, connectionObserver);
+        this._disconnectionObservers.set(index, disconnectionObserver);
+    }
+
+    private _unmanageExtendedInputs(index: number) {
+        const connectionObserver = this._connectionObservers.get(index);
+        const disconnectionObserver = this._disconnectionObservers.get(index);
+
+        if (connectionObserver) {
+            this._inputs[index].onConnectionObservable.remove(connectionObserver);
+            this._connectionObservers.delete(index);
+        }
+
+        if (disconnectionObserver) {
+            this._inputs[index].onDisconnectionObservable.remove(disconnectionObserver);
+            this._disconnectionObservers.delete(index);
+        }
+    }
+
+    public get config(): NodeParticleConnectionPoint {
+        return this._inputs[this._entryCount - 1];
+    }
+
+    public get solidParticle(): NodeParticleConnectionPoint {
+        return this._outputs[0];
+    }
+
+    public override _build(state: NodeParticleBuildState) {
+        if (!state.scene) {
+            throw new Error("Scene is not initialized in NodeParticleBuildState");
+        }
+
+        const sps = new SolidParticleSystem(this.name, state.scene, {
+            useModelMaterial: true,
+        });
+
+        const createBlocks = new Map<number, ISolidParticleInitData>();
+        for (let i = 0; i < this._inputs.length; i++) {
+            const creatData = this._inputs[i].getConnectedValue(state) as ISolidParticleInitData;
+            if (!this._inputs[i].isConnected || !creatData || !creatData.meshData || !creatData.count) {
+                continue;
+            }
+
+            if (!creatData.meshData.vertexData) {
+                continue;
+            }
+
+            const mesh = new Mesh(`${this.name}_shape_${i}`, state.scene);
+            creatData.meshData.vertexData.applyToMesh(mesh, true);
+            if (creatData.material) {
+                mesh.material = creatData.material;
+            }
+
+            const shapeId = sps.addShape(mesh, creatData.count);
+            createBlocks.set(shapeId, creatData);
+            mesh.dispose();
+        }
+
+        sps.initParticles = () => {
+            if (!sps) {
+                return;
+            }
+
+            const originalContext = state.particleContext;
+            const originalSystemContext = state.systemContext;
+
+            try {
+                for (let p = 0; p < sps.nbParticles; p++) {
+                    const particle = sps.particles[p];
+                    const particleCreateData = createBlocks.get(particle.shapeId);
+                    if (!particleCreateData) {
+                        continue;
+                    }
+                    const { lifeTime, position, velocity, color, scaling, rotation } = particleCreateData;
+
+                    state.particleContext = particle;
+                    state.systemContext = sps;
+
+                    if (lifeTime) {
+                        particle.lifeTime = lifeTime();
+                        particle.age = 0;
+                        particle.alive = true;
+                    }
+
+                    if (position) {
+                        particle.position.copyFrom(position());
+                    }
+                    if (velocity) {
+                        particle.velocity.copyFrom(velocity());
+                    }
+                    if (color) {
+                        const particleColor = particle.color;
+                        if (particleColor) {
+                            particleColor.copyFrom(color());
+                        }
+                    }
+                    if (scaling) {
+                        particle.scaling.copyFrom(scaling());
+                    }
+                    if (rotation) {
+                        particle.rotation.copyFrom(rotation());
+                    }
+                }
+            } finally {
+                state.particleContext = originalContext;
+                state.systemContext = originalSystemContext;
+            }
+        };
+
+        sps.updateParticle = (particle: SolidParticle) => {
+            if (!sps) {
+                return particle;
+            }
+
+            const particleCreateData = createBlocks.get(particle.shapeId);
+            const updateBlock = particleCreateData?.updateBlock;
+            if (!updateBlock) {
+                return particle;
+            }
+            // Set particle context in state for PerParticle lock mode
+            const originalContext = state.particleContext;
+            const originalSystemContext = state.systemContext;
+
+            // Temporarily set particle context for PerParticle lock mode
+            state.particleContext = particle;
+            state.systemContext = sps;
+
+            try {
+                if (updateBlock.position) {
+                    particle.position.copyFrom(updateBlock.position());
+                }
+                if (updateBlock.velocity) {
+                    particle.velocity.copyFrom(updateBlock.velocity());
+                }
+                if (updateBlock.color) {
+                    particle.color?.copyFrom(updateBlock.color());
+                }
+                if (updateBlock.scaling) {
+                    particle.scaling.copyFrom(updateBlock.scaling());
+                }
+                if (updateBlock.rotation) {
+                    particle.rotation.copyFrom(updateBlock.rotation());
+                }
+            } finally {
+                // Restore original context
+                state.particleContext = originalContext;
+                state.systemContext = originalSystemContext;
+            }
+            return particle;
+        };
+
+        this.solidParticle._storedValue = sps;
+    }
+
+    public override serialize(): any {
+        const serializationObject = super.serialize();
+        serializationObject._entryCount = this._entryCount;
+        return serializationObject;
+    }
+
+    public override _deserialize(serializationObject: any) {
+        super._deserialize(serializationObject);
+        if (serializationObject._entryCount && serializationObject._entryCount > 1) {
+            for (let i = 1; i < serializationObject._entryCount; i++) {
+                this._extend();
+            }
+        }
+    }
+}
+
+RegisterClass("BABYLON.CreateSolidParticleBlock", CreateSolidParticleBlock);

packages/dev/core/src/Particles/Node/Blocks/SolidParticle/initSolidParticleBlock.ts

@@ -0,0 +1,106 @@
+import type { Color4, Vector3 } from "../../../../Maths";
+import { RegisterClass } from "../../../../Misc/typeStore";
+import { NodeParticleBlockConnectionPointTypes } from "../../Enums/nodeParticleBlockConnectionPointTypes";
+import { NodeParticleBlock } from "../../nodeParticleBlock";
+import type { NodeParticleConnectionPoint } from "../../nodeParticleBlockConnectionPoint";
+import type { NodeParticleBuildState } from "../../nodeParticleBuildState";
+import type { ISolidParticleInitData } from "./ISolidParticleData";
+
+/**
+ * Block used to configure SPS particle parameters (mesh, count, material, position, velocity, color, scaling, rotation)
+ */
+export class InitSolidParticleBlock extends NodeParticleBlock {
+    public constructor(name: string) {
+        super(name);
+
+        this.registerInput("count", NodeParticleBlockConnectionPointTypes.Int, true, 1);
+        this.registerInput("lifeTime", NodeParticleBlockConnectionPointTypes.Float, true, Infinity);
+        this.registerInput("position", NodeParticleBlockConnectionPointTypes.Vector3, true);
+        this.registerInput("velocity", NodeParticleBlockConnectionPointTypes.Vector3, true);
+        this.registerInput("color", NodeParticleBlockConnectionPointTypes.Color4, true);
+        this.registerInput("scaling", NodeParticleBlockConnectionPointTypes.Vector3, true);
+        this.registerInput("rotation", NodeParticleBlockConnectionPointTypes.Vector3, true);
+        this.registerInput("mesh", NodeParticleBlockConnectionPointTypes.Mesh);
+        this.registerInput("material", NodeParticleBlockConnectionPointTypes.Material, true);
+
+        this.registerOutput("config", NodeParticleBlockConnectionPointTypes.SolidParticleConfig);
+    }
+
+    public override getClassName() {
+        return "InitSolidParticleBlock";
+    }
+
+    public get count(): NodeParticleConnectionPoint {
+        return this._inputs[0];
+    }
+
+    public get lifeTime(): NodeParticleConnectionPoint {
+        return this._inputs[1];
+    }
+
+    public get position(): NodeParticleConnectionPoint {
+        return this._inputs[2];
+    }
+
+    public get velocity(): NodeParticleConnectionPoint {
+        return this._inputs[3];
+    }
+
+    public get color(): NodeParticleConnectionPoint {
+        return this._inputs[4];
+    }
+
+    public get scaling(): NodeParticleConnectionPoint {
+        return this._inputs[5];
+    }
+
+    public get rotation(): NodeParticleConnectionPoint {
+        return this._inputs[6];
+    }
+
+    public get mesh(): NodeParticleConnectionPoint {
+        return this._inputs[7];
+    }
+
+    public get material(): NodeParticleConnectionPoint {
+        return this._inputs[8];
+    }
+
+    public get config(): NodeParticleConnectionPoint {
+        return this._outputs[0];
+    }
+
+    public override _build(state: NodeParticleBuildState) {
+        const meshData = this.mesh.getConnectedValue(state);
+        const count = (this.count.getConnectedValue(state) as number) ?? 1;
+        const lifeTime = this.lifeTime.isConnected
+            ? () => {
+                  return (this.lifeTime.getConnectedValue(state) as number) ?? Infinity;
+              }
+            : undefined;
+        const material = this.material.getConnectedValue(state);
+
+        const position = this.position.isConnected ? () => this.position.getConnectedValue(state) as Vector3 : undefined;
+        const velocity = this.velocity.isConnected ? () => this.velocity.getConnectedValue(state) as Vector3 : undefined;
+        const color = this.color.isConnected ? () => this.color.getConnectedValue(state) as Color4 : undefined;
+        const scaling = this.scaling.isConnected ? () => this.scaling.getConnectedValue(state) as Vector3 : undefined;
+        const rotation = this.rotation.isConnected ? () => this.rotation.getConnectedValue(state) as Vector3 : undefined;
+
+        const particleConfig: ISolidParticleInitData = {
+            meshData,
+            count,
+            material,
+            lifeTime,
+            position,
+            velocity,
+            color,
+            scaling,
+            rotation,
+            updateBlock: null,
+        };
+
+        this.config._storedValue = particleConfig;
+    }
+}
+
+RegisterClass("BABYLON.InitSolidParticleBlock", InitSolidParticleBlock);