@babylonjs/core 9.3.0 → 9.3.1

package/Particles/gpuParticleSystem.js

@@ -23,7 +23,7 @@ import "../Engines/Extensions/engine.transformFeedback.js";
 import "../Shaders/gpuRenderParticles.fragment.js";
 import "../Shaders/gpuRenderParticles.vertex.js";
 import { BindFogParameters, BindLogDepth } from "../Materials/materialHelper.functions.js";
-import { CreateConeEmitter, CreateCylinderEmitter, CreateDirectedCylinderEmitter, CreateDirectedSphereEmitter, CreateDirectedConeEmitter, CreateHemisphericEmitter, CreatePointEmitter, CreateSphereEmitter, } from "./particleSystem.functions.js";
+import { MeshParticleEmitter } from "./EmitterTypes/meshParticleEmitter.js";
 /**
  * This represents a GPU particle system in Babylon
  * This is the fastest particle system in Babylon as it uses the GPU to update the individual particle data
@@ -101,111 +101,6 @@ export class GPUParticleSystem extends BaseParticleSystem {
         }
         super.addAttractor(attractor);
     }
-    /**
-     * Creates a Point Emitter for the particle system (emits directly from the emitter position)
-     * @param direction1 Particles are emitted between the direction1 and direction2 from within the box
-     * @param direction2 Particles are emitted between the direction1 and direction2 from within the box
-     * @returns the emitter
-     */
-    createPointEmitter(direction1, direction2) {
-        const particleEmitter = CreatePointEmitter(direction1, direction2);
-        this.particleEmitterType = particleEmitter;
-        return particleEmitter;
-    }
-    /**
-     * Creates a Hemisphere Emitter for the particle system (emits along the hemisphere radius)
-     * @param radius The radius of the hemisphere to emit from
-     * @param radiusRange The range of the hemisphere to emit from [0-1] 0 Surface Only, 1 Entire Radius
-     * @returns the emitter
-     */
-    createHemisphericEmitter(radius = 1, radiusRange = 1) {
-        const particleEmitter = CreateHemisphericEmitter(radius, radiusRange);
-        this.particleEmitterType = particleEmitter;
-        return particleEmitter;
-    }
-    /**
-     * Creates a Sphere Emitter for the particle system (emits along the sphere radius)
-     * @param radius The radius of the sphere to emit from
-     * @param radiusRange The range of the sphere to emit from [0-1] 0 Surface Only, 1 Entire Radius
-     * @returns the emitter
-     */
-    createSphereEmitter(radius = 1, radiusRange = 1) {
-        const particleEmitter = CreateSphereEmitter(radius, radiusRange);
-        this.particleEmitterType = particleEmitter;
-        return particleEmitter;
-    }
-    /**
-     * Creates a Directed Sphere Emitter for the particle system (emits between direction1 and direction2)
-     * @param radius The radius of the sphere to emit from
-     * @param direction1 Particles are emitted between the direction1 and direction2 from within the sphere
-     * @param direction2 Particles are emitted between the direction1 and direction2 from within the sphere
-     * @returns the emitter
-     */
-    createDirectedSphereEmitter(radius = 1, direction1 = new Vector3(0, 1.0, 0), direction2 = new Vector3(0, 1.0, 0)) {
-        const particleEmitter = CreateDirectedSphereEmitter(radius, direction1, direction2);
-        this.particleEmitterType = particleEmitter;
-        return particleEmitter;
-    }
-    /**
-     * Creates a Cylinder Emitter for the particle system (emits from the cylinder to the particle position)
-     * @param radius The radius of the emission cylinder
-     * @param height The height of the emission cylinder
-     * @param radiusRange The range of emission [0-1] 0 Surface only, 1 Entire Radius
-     * @param directionRandomizer How much to randomize the particle direction [0-1]
-     * @returns the emitter
-     */
-    createCylinderEmitter(radius = 1, height = 1, radiusRange = 1, directionRandomizer = 0) {
-        const particleEmitter = CreateCylinderEmitter(radius, height, radiusRange, directionRandomizer);
-        this.particleEmitterType = particleEmitter;
-        return particleEmitter;
-    }
-    /**
-     * Creates a Directed Cylinder Emitter for the particle system (emits between direction1 and direction2)
-     * @param radius The radius of the cylinder to emit from
-     * @param height The height of the emission cylinder
-     * @param radiusRange the range of the emission cylinder [0-1] 0 Surface only, 1 Entire Radius (1 by default)
-     * @param direction1 Particles are emitted between the direction1 and direction2 from within the cylinder
-     * @param direction2 Particles are emitted between the direction1 and direction2 from within the cylinder
-     * @returns the emitter
-     */
-    createDirectedCylinderEmitter(radius = 1, height = 1, radiusRange = 1, direction1 = new Vector3(0, 1.0, 0), direction2 = new Vector3(0, 1.0, 0)) {
-        const particleEmitter = CreateDirectedCylinderEmitter(radius, height, radiusRange, direction1, direction2);
-        this.particleEmitterType = particleEmitter;
-        return particleEmitter;
-    }
-    /**
-     * Creates a Cone Emitter for the particle system (emits from the cone to the particle position)
-     * @param radius The radius of the cone to emit from
-     * @param angle The base angle of the cone
-     * @returns the emitter
-     */
-    createConeEmitter(radius = 1, angle = Math.PI / 4) {
-        const particleEmitter = CreateConeEmitter(radius, angle);
-        this.particleEmitterType = particleEmitter;
-        return particleEmitter;
-    }
-    createDirectedConeEmitter(radius = 1, angle = Math.PI / 4, direction1 = new Vector3(0, 1.0, 0), direction2 = new Vector3(0, 1.0, 0)) {
-        const particleEmitter = CreateDirectedConeEmitter(radius, angle, direction1, direction2);
-        this.particleEmitterType = particleEmitter;
-        return particleEmitter;
-    }
-    /**
-     * Creates a Box Emitter for the particle system. (emits between direction1 and direction2 from withing the box defined by minEmitBox and maxEmitBox)
-     * @param direction1 Particles are emitted between the direction1 and direction2 from within the box
-     * @param direction2 Particles are emitted between the direction1 and direction2 from within the box
-     * @param minEmitBox Particles are emitted from the box between minEmitBox and maxEmitBox
-     * @param maxEmitBox  Particles are emitted from the box between minEmitBox and maxEmitBox
-     * @returns the emitter
-     */
-    createBoxEmitter(direction1, direction2, minEmitBox, maxEmitBox) {
-        const particleEmitter = new BoxParticleEmitter();
-        this.particleEmitterType = particleEmitter;
-        this.direction1 = direction1;
-        this.direction2 = direction2;
-        this.minEmitBox = minEmitBox;
-        this.maxEmitBox = maxEmitBox;
-        return particleEmitter;
-    }
     /** Gets or sets the current flow map */
     get flowMap() {
         return this._flowMap;
@@ -825,6 +720,18 @@ export class GPUParticleSystem extends BaseParticleSystem {
          * The strength of the flow map
          */
         this.flowMapStrength = 1.0;
+        /** Mesh emitter textures */
+        /** @internal */
+        this._meshPositionTexture = null;
+        /** @internal */
+        this._meshNormalTexture = null;
+        /** @internal */
+        this._meshTriangleCount = 0;
+        /** @internal */
+        this._meshTextureWidth = 0;
+        // Track mesh emitter inputs for invalidation
+        this._meshEmitterMeshId = -1;
+        this._meshEmitterUsedNormals = false;
         /** @internal */
         this._onBeforeDrawParticlesObservable = null;
         if (!sceneOrEngine || sceneOrEngine.getClassName() === "Scene") {
@@ -1152,6 +1059,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
         this._createVelocityGradientTexture();
         this._createLimitVelocityGradientTexture();
         this._createDragGradientTexture();
+        this._createMeshEmitterTextures();
         let defines = this.particleEmitterType ? this.particleEmitterType.getEffectDefines() : "";
         if (this._isBillboardBased) {
             // Stretched local needs initialDirection in the buffer, which requires !BILLBOARD in the update shader.
@@ -1206,6 +1114,12 @@ export class GPUParticleSystem extends BaseParticleSystem {
         if (this._lifeTimeGradients && this._lifeTimeGradients.length > 0) {
             defines += "\n#define LIFETIMEGRADIENTS";
         }
+        if (this.particleEmitterType instanceof MeshParticleEmitter && this._meshPositionTexture) {
+            defines += "\n#define MESHEMITTER";
+            if (this._meshNormalTexture) {
+                defines += "\n#define MESHNORMALS";
+            }
+        }
         if (this._platform.isUpdateBufferCreated() && this._cachedUpdateDefines === defines) {
             return this._platform.isUpdateBufferReady();
         }
@@ -1400,6 +1314,109 @@ export class GPUParticleSystem extends BaseParticleSystem {
     _createDragGradientTexture() {
         this._createFactorGradientTexture(this._dragGradients, "_dragGradientsTexture");
     }
+    _disposeMeshEmitterTextures() {
+        if (this._meshPositionTexture) {
+            this._meshPositionTexture.dispose();
+            this._meshPositionTexture = null;
+        }
+        if (this._meshNormalTexture) {
+            this._meshNormalTexture.dispose();
+            this._meshNormalTexture = null;
+        }
+        this._meshTriangleCount = 0;
+        this._meshTextureWidth = 0;
+        this._meshEmitterMeshId = -1;
+        this._meshEmitterUsedNormals = false;
+    }
+    _createMeshEmitterTextures() {
+        if (!(this.particleEmitterType instanceof MeshParticleEmitter)) {
+            // Emitter type changed away from mesh — dispose stale textures
+            if (this._meshPositionTexture) {
+                this._disposeMeshEmitterTextures();
+            }
+            return;
+        }
+        const meshEmitter = this.particleEmitterType;
+        const mesh = meshEmitter.mesh;
+        if (!mesh) {
+            // Mesh removed — dispose stale textures
+            if (this._meshPositionTexture) {
+                this._disposeMeshEmitterTextures();
+            }
+            return;
+        }
+        const useNormals = meshEmitter.useMeshNormalsForDirection;
+        // Invalidate if the source mesh or normals usage changed
+        if (this._meshPositionTexture && (mesh.uniqueId !== this._meshEmitterMeshId || useNormals !== this._meshEmitterUsedNormals)) {
+            this._disposeMeshEmitterTextures();
+        }
+        // Already created and still valid
+        if (this._meshPositionTexture) {
+            return;
+        }
+        const positions = mesh.getVerticesData(VertexBuffer.PositionKind);
+        const normals = mesh.getVerticesData(VertexBuffer.NormalKind);
+        const indices = mesh.getIndices();
+        if (!positions || !indices) {
+            return;
+        }
+        const triangleCount = indices.length / 3;
+        this._meshTriangleCount = triangleCount;
+        // Use a 2D texture layout so large meshes don't exceed maxTextureSize
+        const totalTexels = triangleCount * 3;
+        const maxTexSize = this._engine.getCaps().maxTextureSize;
+        const texWidth = Math.min(totalTexels, maxTexSize);
+        const texHeight = Math.ceil(totalTexels / texWidth);
+        this._meshTextureWidth = texWidth;
+        // Pack vertex positions: one texel per vertex, 3 vertices per triangle, RGBA float (xyz + padding)
+        const posData = new Float32Array(texWidth * texHeight * 4);
+        for (let t = 0; t < triangleCount; t++) {
+            const i0 = indices[t * 3];
+            const i1 = indices[t * 3 + 1];
+            const i2 = indices[t * 3 + 2];
+            const baseOffset = t * 3 * 4;
+            posData[baseOffset] = positions[i0 * 3];
+            posData[baseOffset + 1] = positions[i0 * 3 + 1];
+            posData[baseOffset + 2] = positions[i0 * 3 + 2];
+            posData[baseOffset + 3] = 0;
+            posData[baseOffset + 4] = positions[i1 * 3];
+            posData[baseOffset + 5] = positions[i1 * 3 + 1];
+            posData[baseOffset + 6] = positions[i1 * 3 + 2];
+            posData[baseOffset + 7] = 0;
+            posData[baseOffset + 8] = positions[i2 * 3];
+            posData[baseOffset + 9] = positions[i2 * 3 + 1];
+            posData[baseOffset + 10] = positions[i2 * 3 + 2];
+            posData[baseOffset + 11] = 0;
+        }
+        this._meshPositionTexture = new RawTexture(posData, texWidth, texHeight, 5, this._scene || this._engine, false, false, 1, 1);
+        this._meshPositionTexture.name = "meshPositionTexture";
+        // Pack normals the same way if available
+        if (normals && useNormals) {
+            const normData = new Float32Array(texWidth * texHeight * 4);
+            for (let t = 0; t < triangleCount; t++) {
+                const i0 = indices[t * 3];
+                const i1 = indices[t * 3 + 1];
+                const i2 = indices[t * 3 + 2];
+                const baseOffset = t * 3 * 4;
+                normData[baseOffset] = normals[i0 * 3];
+                normData[baseOffset + 1] = normals[i0 * 3 + 1];
+                normData[baseOffset + 2] = normals[i0 * 3 + 2];
+                normData[baseOffset + 3] = 0;
+                normData[baseOffset + 4] = normals[i1 * 3];
+                normData[baseOffset + 5] = normals[i1 * 3 + 1];
+                normData[baseOffset + 6] = normals[i1 * 3 + 2];
+                normData[baseOffset + 7] = 0;
+                normData[baseOffset + 8] = normals[i2 * 3];
+                normData[baseOffset + 9] = normals[i2 * 3 + 1];
+                normData[baseOffset + 10] = normals[i2 * 3 + 2];
+                normData[baseOffset + 11] = 0;
+            }
+            this._meshNormalTexture = new RawTexture(normData, texWidth, texHeight, 5, this._scene || this._engine, false, false, 1, 1);
+            this._meshNormalTexture.name = "meshNormalTexture";
+        }
+        this._meshEmitterMeshId = mesh.uniqueId;
+        this._meshEmitterUsedNormals = useNormals;
+    }
     _createColorGradientTexture() {
         if (!this._colorGradients || !this._colorGradients.length || this._colorGradientsTexture) {
             return;
@@ -1574,6 +1591,10 @@ export class GPUParticleSystem extends BaseParticleSystem {
         if (this._lifeTimeGradients && this._lifeTimeGradients.length > 0) {
             this._updateBuffer.setFloat2("lifeTimeGradientRange", this._lifeTimeGradientMin, this._lifeTimeGradientMax);
         }
+        if (this._meshPositionTexture) {
+            this._updateBuffer.setInt("meshTriangleCount", this._meshTriangleCount);
+            this._updateBuffer.setInt("meshTextureWidth", this._meshTextureWidth);
+        }
         this._platform.updateParticleBuffer(this._targetIndex, this._targetBuffer, this._currentActiveCount);
         // Switch VAOs
         this._targetIndex++;
@@ -1773,6 +1794,8 @@ export class GPUParticleSystem extends BaseParticleSystem {
         };
         this._createIndexBuffer();
         this._cachedUpdateDefines = "";
+        // Re-upload mesh emitter data if the mesh geometry changed
+        this._disposeMeshEmitterTextures();
         this._platform.contextLost();
         this._rebuildingAfterContextLost = true;
         checkUpdateEffect();
@@ -1841,6 +1864,7 @@ export class GPUParticleSystem extends BaseParticleSystem {
             this._dragGradientsTexture.dispose();
             this._dragGradientsTexture = null;
         }
+        this._disposeMeshEmitterTextures();
         if (this._randomTexture) {
             this._randomTexture.dispose();
             this._randomTexture = null;