[NPE] Particles directed cone emitter (#17446)

Adds direction support for ConeShapeBlock. DirectionRandomizer will be
used unless both direction1 and direction2 are assigned.

PG to test: #UL4WC0#117
<img width="1018" height="861" alt="image"
src="https://github.com/user-attachments/assets/ea552c78-f28b-4d96-8833-f11f4d771b3a"
/>

Author: VicenteCartas

packages/dev/core/src/Particles/EmitterTypes/coneParticleEmitter.ts

@@ -249,11 +249,19 @@ export class ConeDirectedParticleEmitter extends ConeParticleEmitter {
      * Called by the particle System when the direction is computed for the created particle.
      * @param worldMatrix is the world matrix of the particle system
      * @param directionToUpdate is the direction vector to update with the result
+     * @param particle is the particle we are computed the position for
+     * @param isLocal defines if the direction should be set in local space
      */
-    public override startDirectionFunction(worldMatrix: Matrix, directionToUpdate: Vector3): void {
+    public override startDirectionFunction(worldMatrix: Matrix, directionToUpdate: Vector3, particle: Particle, isLocal: boolean): void {
         const randX = RandomRange(this.direction1.x, this.direction2.x);
         const randY = RandomRange(this.direction1.y, this.direction2.y);
         const randZ = RandomRange(this.direction1.z, this.direction2.z);
+
+        if (isLocal) {
+            directionToUpdate.copyFromFloats(randX, randY, randZ);
+            return;
+        }
+
         Vector3.TransformNormalFromFloatsToRef(randX, randY, randZ, worldMatrix, directionToUpdate);
     }
 

packages/dev/core/src/Particles/Node/Blocks/Emitters/coneShapeBlock.ts

@@ -17,6 +17,7 @@ import { _CreateLocalPositionData } from "./emitters.functions";
 export class ConeShapeBlock extends NodeParticleBlock implements IShapeBlock {
     /**
      * Gets or sets a boolean indicating if the system should emit only from the spawn point
+     * DirectionRandomizer will be used for the particles initial direction unless both direction1 and direction2 are connected.
      */
     @editableInPropertyPage("Emit from spawn point only", PropertyTypeForEdition.Boolean, "ADVANCED", { embedded: true, notifiers: { rebuild: true } })
     public emitFromSpawnPointOnly = false;
@@ -34,6 +35,8 @@ export class ConeShapeBlock extends NodeParticleBlock implements IShapeBlock {
         this.registerInput("radiusRange", NodeParticleBlockConnectionPointTypes.Float, true, 1);
         this.registerInput("heightRange", NodeParticleBlockConnectionPointTypes.Float, true, 1);
         this.registerInput("directionRandomizer", NodeParticleBlockConnectionPointTypes.Float, true, 0);
+        this.registerInput("direction1", NodeParticleBlockConnectionPointTypes.Vector3, true);
+        this.registerInput("direction2", NodeParticleBlockConnectionPointTypes.Vector3, true);
         this.registerOutput("output", NodeParticleBlockConnectionPointTypes.Particle);
     }
 
@@ -87,6 +90,20 @@ export class ConeShapeBlock extends NodeParticleBlock implements IShapeBlock {
         return this._inputs[5];
     }
 
+    /**
+     * Gets the direction1 input component
+     */
+    public get direction1(): NodeParticleConnectionPoint {
+        return this._inputs[6];
+    }
+
+    /**
+     * Gets the direction2 input component
+     */
+    public get direction2(): NodeParticleConnectionPoint {
+        return this._inputs[7];
+    }
+
     /**
      * Gets the output component
      */
@@ -105,21 +122,37 @@ export class ConeShapeBlock extends NodeParticleBlock implements IShapeBlock {
             state.particleContext = particle;
             state.systemContext = system;
 
-            const directionRandomizer = this.directionRandomizer.getConnectedValue(state) as number;
-
-            const direction = particle.position.subtract(state.emitterPosition!).normalize();
-            const randX = RandomRange(0, directionRandomizer);
-            const randY = RandomRange(0, directionRandomizer);
-            const randZ = RandomRange(0, directionRandomizer);
-            direction.x += randX;
-            direction.y += randY;
-            direction.z += randZ;
-            direction.normalize();
-
-            if (system.isLocal) {
-                particle.direction.copyFromFloats(direction.x, direction.y, direction.z);
+            // We always use directionRandomizer unless both directions are connected
+            if (this.direction1.isConnected === false || this.direction2.isConnected === false) {
+                const directionRandomizer = this.directionRandomizer.getConnectedValue(state) as number;
+
+                const direction = particle.position.subtract(state.emitterPosition!).normalize();
+                const randX = RandomRange(0, directionRandomizer);
+                const randY = RandomRange(0, directionRandomizer);
+                const randZ = RandomRange(0, directionRandomizer);
+                direction.x += randX;
+                direction.y += randY;
+                direction.z += randZ;
+                direction.normalize();
+
+                if (system.isLocal) {
+                    particle.direction.copyFromFloats(direction.x, direction.y, direction.z);
+                } else {
+                    Vector3.TransformNormalFromFloatsToRef(direction.x, direction.y, direction.z, state.emitterWorldMatrix!, particle.direction);
+                }
             } else {
-                Vector3.TransformNormalFromFloatsToRef(direction.x, direction.y, direction.z, state.emitterWorldMatrix!, particle.direction);
+                const direction1 = this.direction1.getConnectedValue(state) as Vector3;
+                const direction2 = this.direction2.getConnectedValue(state) as Vector3;
+
+                const randX = RandomRange(direction1.x, direction2.x);
+                const randY = RandomRange(direction1.y, direction2.y);
+                const randZ = RandomRange(direction1.z, direction2.z);
+
+                if (system.isLocal) {
+                    particle.direction.copyFromFloats(randX, randY, randZ);
+                } else {
+                    Vector3.TransformNormalFromFloatsToRef(randX, randY, randZ, state.emitterWorldMatrix!, particle.direction);
+                }
             }
 
             particle._initialDirection = particle.direction.clone();

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

@@ -6,7 +6,7 @@ import type { ColorGradient } from "core/Misc";
 import type { ParticleSystem } from "core/Particles/particleSystem";
 import type { IParticleSystem } from "core/Particles/IParticleSystem";
 import type { BoxParticleEmitter } from "core/Particles/EmitterTypes/boxParticleEmitter";
-import type { ConeParticleEmitter } from "core/Particles/EmitterTypes/coneParticleEmitter";
+import type { ConeDirectedParticleEmitter, ConeParticleEmitter } from "core/Particles/EmitterTypes/coneParticleEmitter";
 import type { CustomParticleEmitter } from "core/Particles/EmitterTypes/customParticleEmitter";
 import type { CylinderDirectedParticleEmitter, CylinderParticleEmitter } from "core/Particles/EmitterTypes/cylinderParticleEmitter";
 import type { HemisphericParticleEmitter } from "core/Particles/EmitterTypes/hemisphericParticleEmitter";
@@ -197,6 +197,20 @@ function _CreateEmitterShapeBlock(oldSystem: IParticleSystem): IShapeBlock {
             _CreateAndConnectInput("Direction Randomizer", source.directionRandomizer, target.directionRandomizer);
             break;
         }
+        case "ConeDirectedParticleEmitter": {
+            const source = emitter as ConeDirectedParticleEmitter;
+            shapeBlock = new ConeShapeBlock("Cone Shape");
+
+            const target = shapeBlock as ConeShapeBlock;
+            target.emitFromSpawnPointOnly = source.emitFromSpawnPointOnly;
+            _CreateAndConnectInput("Radius", source.radius, target.radius);
+            _CreateAndConnectInput("Angle", source.angle, target.angle);
+            _CreateAndConnectInput("Radius Range", source.radiusRange, target.radiusRange);
+            _CreateAndConnectInput("Height Range", source.heightRange, target.heightRange);
+            _CreateAndConnectInput("Direction 1", source.direction1, target.direction1);
+            _CreateAndConnectInput("Direction 2", source.direction2, target.direction2);
+            break;
+        }
         case "CustomParticleEmitter": {
             const source = emitter as CustomParticleEmitter;
             shapeBlock = new CustomShapeBlock("Custom Shape");