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/ISPSData.ts

@@ -0,0 +1,26 @@
+import type { Vector3 } from "core/Maths/math.vector";
+import type { Color4 } from "core/Maths/math.color";
+import type { Mesh } from "core/Meshes/mesh";
+import type { Material } from "core/Materials/material";
+
+/**
+ * Interface for SPS update block data
+ */
+export interface ISpsUpdateData {
+    position?: () => Vector3;
+    velocity?: () => Vector3;
+    color?: () => Color4;
+    scaling?: () => Vector3;
+    rotation?: () => Vector3;
+}
+
+/**
+ * Interface for SPS create block data
+ */
+export interface ISpsParticleConfigData {
+    mesh: Mesh;
+    count: number;
+    material?: Material;
+    initBlock?: ISpsUpdateData;
+    updateBlock?: ISpsUpdateData;
+}

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

@@ -0,0 +1,129 @@
+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 { SolidParticle } from "../../../solidParticle";
+import { editableInPropertyPage, PropertyTypeForEdition } from "../../../../Decorators/nodeDecorator";
+import { serialize } from "../../../../Misc/decorators";
+
+/**
+ * Block used to get custom properties from particle.props
+ * Works similar to contextual blocks but for dynamic property names
+ */
+export class SpsParticlePropsGetBlock extends NodeParticleBlock {
+    /**
+     * Gets or sets the property name to read from particle.props
+     */
+    @serialize("propertyName")
+    @editableInPropertyPage("Property Name", PropertyTypeForEdition.String, "PROPERTIES", {
+        embedded: false,
+        notifiers: { rebuild: true },
+    })
+    public propertyName: string = "value";
+
+    /**
+     * Gets or sets the connection point type (default float)
+     */
+    private _type: NodeParticleBlockConnectionPointTypes = NodeParticleBlockConnectionPointTypes.Float;
+
+    /**
+     * Gets the value to display (returns propertyName as string)
+     */
+    public get displayValue(): string {
+        return this.propertyName || "value";
+    }
+
+    public constructor(name: string) {
+        super(name);
+
+        this.registerOutput("output", NodeParticleBlockConnectionPointTypes.AutoDetect);
+        // Set default type
+        (this._outputs[0] as any)._defaultConnectionPointType = this._type;
+    }
+
+    public override getClassName() {
+        return "SpsParticlePropsGetBlock";
+    }
+
+    /**
+     * Gets or sets the connection point type
+     */
+    public get type(): NodeParticleBlockConnectionPointTypes {
+        return this._type;
+    }
+
+    public set type(value: NodeParticleBlockConnectionPointTypes) {
+        if (this._type !== value) {
+            this._type = value;
+            // Update output type
+            (this._outputs[0] as any)._type = value;
+            (this._outputs[0] as any)._defaultConnectionPointType = value;
+        }
+    }
+
+    public get output(): NodeParticleConnectionPoint {
+        return this._outputs[0];
+    }
+
+    public override _build(state: NodeParticleBuildState) {
+        // Validate property name
+        if (!this.propertyName || this.propertyName.trim() === "") {
+            this.output._storedFunction = null;
+            this.output._storedValue = null;
+            return;
+        }
+
+        // Validate type
+        if (this._type === NodeParticleBlockConnectionPointTypes.Undefined || this._type === NodeParticleBlockConnectionPointTypes.AutoDetect) {
+            this._type = NodeParticleBlockConnectionPointTypes.Float;
+            (this._outputs[0] as any)._type = this._type;
+            (this._outputs[0] as any)._defaultConnectionPointType = this._type;
+        }
+
+        const propertyName = this.propertyName;
+
+        const func = (state: NodeParticleBuildState) => {
+            if (!state.particleContext) {
+                return null;
+            }
+
+            const particle = state.particleContext as SolidParticle;
+
+            if (!particle.props) {
+                return null;
+            }
+
+            const value = particle.props[propertyName];
+
+            if (value === undefined) {
+                return null;
+            }
+
+            return value;
+        };
+
+        if (this.output.isConnected) {
+            this.output._storedFunction = func;
+        } else {
+            this.output._storedValue = func(state);
+        }
+    }
+
+    public override serialize(): any {
+        const serializationObject = super.serialize();
+        serializationObject.propertyName = this.propertyName;
+        serializationObject.type = this._type;
+        return serializationObject;
+    }
+
+    public override _deserialize(serializationObject: any) {
+        super._deserialize(serializationObject);
+        this.propertyName = serializationObject.propertyName || "value";
+        this._type = serializationObject.type || NodeParticleBlockConnectionPointTypes.Float;
+        (this._outputs[0] as any)._type = this._type;
+        (this._outputs[0] as any)._defaultConnectionPointType = this._type;
+    }
+}
+
+RegisterClass("BABYLON.SpsParticlePropsGetBlock", SpsParticlePropsGetBlock);

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

@@ -0,0 +1,133 @@
+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 { SolidParticle } from "../../../solidParticle";
+import { editableInPropertyPage, PropertyTypeForEdition } from "../../../../Decorators/nodeDecorator";
+import { serialize } from "../../../../Misc/decorators";
+
+/**
+ * Block used to set custom properties in particle.props
+ * Works as a side-effect block that stores values and passes them through
+ */
+export class SpsParticlePropsSetBlock extends NodeParticleBlock {
+    /**
+     * Gets or sets the property name to store in particle.props
+     */
+    @serialize("propertyName")
+    @editableInPropertyPage("Property Name", PropertyTypeForEdition.String, "PROPERTIES", {
+        embedded: false,
+        notifiers: { rebuild: true },
+    })
+    public propertyName: string = "value";
+
+    /**
+     * Gets or sets the connection point type (default float)
+     */
+    private _type: NodeParticleBlockConnectionPointTypes = NodeParticleBlockConnectionPointTypes.Float;
+
+    public constructor(name: string) {
+        super(name);
+
+        this.registerInput("value", NodeParticleBlockConnectionPointTypes.AutoDetect, true);
+        this.registerOutput("output", NodeParticleBlockConnectionPointTypes.BasedOnInput);
+
+        // Link output type to input type
+        this._outputs[0]._typeConnectionSource = this._inputs[0];
+        // Set default type for when input is not connected
+        (this._outputs[0] as any)._defaultConnectionPointType = this._type;
+    }
+
+    public override getClassName() {
+        return "SpsParticlePropsSetBlock";
+    }
+
+    public get value(): NodeParticleConnectionPoint {
+        return this._inputs[0];
+    }
+
+    /**
+     * Gets the value to display (returns propertyName as string)
+     * This shadows the connection point name for display purposes
+     */
+    public get displayValue(): string {
+        return this.propertyName || "value";
+    }
+
+    public get output(): NodeParticleConnectionPoint {
+        return this._outputs[0];
+    }
+
+    /**
+     * Gets or sets the connection point type
+     */
+    public get type(): NodeParticleBlockConnectionPointTypes {
+        return this._type;
+    }
+
+    public set type(value: NodeParticleBlockConnectionPointTypes) {
+        if (this._type !== value) {
+            this._type = value;
+            // Update default type (used when input is not connected)
+            (this._outputs[0] as any)._defaultConnectionPointType = value;
+        }
+    }
+
+    public override _build(state: NodeParticleBuildState) {
+        // Validate property name
+        if (!this.propertyName || this.propertyName.trim() === "") {
+            this.output._storedFunction = null;
+            this.output._storedValue = null;
+            return;
+        }
+
+        if (!this.value.isConnected) {
+            this.output._storedFunction = null;
+            this.output._storedValue = null;
+            return;
+        }
+
+        const propertyName = this.propertyName;
+
+        const func = (state: NodeParticleBuildState) => {
+            if (!state.particleContext) {
+                return null;
+            }
+
+            const particle = state.particleContext as SolidParticle;
+
+            const value = this.value.getConnectedValue(state);
+
+            if (!particle.props) {
+                particle.props = {};
+            }
+
+            particle.props[propertyName] = value;
+
+            return value;
+        };
+
+        if (this.output.isConnected) {
+            this.output._storedFunction = func;
+        } else {
+            this.output._storedValue = func(state);
+        }
+    }
+
+    public override serialize(): any {
+        const serializationObject = super.serialize();
+        serializationObject.propertyName = this.propertyName;
+        serializationObject.type = this._type;
+        return serializationObject;
+    }
+
+    public override _deserialize(serializationObject: any) {
+        super._deserialize(serializationObject);
+        this.propertyName = serializationObject.propertyName || "value";
+        this._type = serializationObject.type || NodeParticleBlockConnectionPointTypes.Float;
+        (this._outputs[0] as any)._defaultConnectionPointType = this._type;
+    }
+}
+
+RegisterClass("BABYLON.SpsParticlePropsSetBlock", SpsParticlePropsSetBlock);