@directivegames/genesys.js 3.1.24

package/dist/src/components/visual/ParticleEmitterComponent.js

@@ -0,0 +1,569 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+/**
+ * ParticleEmitterComponent spawns and animates simple particles in the scene.
+ *
+ * @deprecated This component is deprecated. For new projects, consider VFXComponent which uses
+ * the wawa-vfx-vanilla particle system with more features and better performance. Note that
+ * VFXComponent is not a drop-in replacement - it uses a different API (JSON-based definitions)
+ * and feature set. ParticleEmitterComponent will continue to work for existing games.
+ *
+ * For new VFX work:
+ * - Use VFXComponent with JSON definitions (see assets/dev/vfx/fire-example.json)
+ * - Use GlobalParticleManager.spawnVFX() for ad-hoc effects
+ * - See wawa-vfx-vanilla documentation for advanced features
+ *
+ * Using THREE.Points under the hood, it supports several emission shapes and
+ * optional textures. Particles have configurable lifetime, speed, color, and can
+ * emit continuously or in bursts. The component updates particle positions each
+ * tick and exposes hooks for custom emission rates or external texture loading.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Set `particleTextureUrl` or `particleTexture` to give particles a visual
+ *   style.
+ * - Choose an `EmissionShape` and tune emitter options for the desired effect.
+ * - Call `emitParticles` manually for one-shot bursts if `emitContinuously` is
+ *   false.
+ */
+import * as THREE from 'three';
+import { UrlTexture } from '../../render/Texture.js';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { SceneComponent } from '../SceneComponent.js';
+/**
+ * @deprecated Use VFXComponent instead
+ */
+export var EmissionShape;
+(function (EmissionShape) {
+    EmissionShape["Sphere"] = "sphere";
+    EmissionShape["Cone"] = "cone";
+    EmissionShape["Disc"] = "disc";
+    EmissionShape["Box"] = "box"; // Emit within a box-shaped area
+})(EmissionShape || (EmissionShape = {}));
+let ParticleEmitterComponent = class ParticleEmitterComponent extends SceneComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...SceneComponent.DEFAULT_OPTIONS,
+            particleCount: 100,
+            particleSize: 1,
+            particleColor: new THREE.Color(1, 1, 1),
+            particleSpeed: 1,
+            particleLifetime: 1,
+            emitterRate: 10,
+            emitContinuously: true,
+            emissionShape: EmissionShape.Sphere,
+            emissionDirection: new THREE.Vector3(0, 1, 0),
+            emissionAngle: 30,
+            emissionRadius: 1,
+            emissionDimensions: new THREE.Vector3(1, 1, 1),
+            particleAlphaTest: 0.1,
+            particleTexture: undefined,
+            particleTextureUrl: undefined,
+            particleAlphaMap: undefined
+        };
+    }
+    constructor(options) {
+        super(options);
+        Object.defineProperty(this, "particles", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "particleSystem", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "particleMaterial", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "particlePositions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "particleVelocities", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "particleLifetimes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "positionAttribute", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "sizeAttribute", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "timeAccumulator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "hasEmittedOnce", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        // Default emission direction is up
+        Object.defineProperty(this, "emissionDirection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new THREE.Vector3(0, 1, 0)
+        });
+        // For texture loading
+        Object.defineProperty(this, "particleTexture", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Initialize emission direction if provided
+        if (options.emissionDirection) {
+            this.emissionDirection = options.emissionDirection.clone().normalize();
+        }
+        // Handle texture loading before initializing the particle system
+        this.loadTextures();
+        this.initializeParticleSystem();
+    }
+    /**
+     * Load any textures needed for the particle system
+     */
+    loadTextures() {
+        // If a texture URL is provided, load it
+        if (this.options.particleTextureUrl) {
+            try {
+                this.particleTexture = new UrlTexture({ url: this.options.particleTextureUrl });
+                this.options.particleTexture = this.particleTexture;
+            }
+            catch (error) {
+                console.error('Failed to load particle texture:', error);
+            }
+        }
+        else if (this.options.particleTexture) {
+            // Use provided texture directly
+            this.particleTexture = this.options.particleTexture;
+        }
+    }
+    initializeParticleSystem() {
+        const particleCount = this.options.particleCount;
+        // Create geometry for particles
+        this.particleSystem = new THREE.BufferGeometry();
+        // Create arrays for particle data
+        this.particlePositions = new Float32Array(particleCount * 3);
+        this.particleVelocities = new Float32Array(particleCount * 3);
+        this.particleLifetimes = new Float32Array(particleCount);
+        // Initialize particle data
+        for (let i = 0; i < particleCount; i++) {
+            // Set all particles to inactive initially
+            this.particleLifetimes[i] = 0;
+        }
+        // Create buffer attributes
+        this.positionAttribute = new THREE.BufferAttribute(this.particlePositions, 3);
+        this.particleSystem.setAttribute('position', this.positionAttribute);
+        const sizes = new Float32Array(particleCount);
+        for (let i = 0; i < particleCount; i++) {
+            sizes[i] = this.options.particleSize;
+        }
+        this.sizeAttribute = new THREE.BufferAttribute(sizes, 1);
+        this.particleSystem.setAttribute('size', this.sizeAttribute);
+        // Create material with texture support
+        this.createParticleMaterial();
+        // Create the particle system
+        this.particles = new THREE.Points(this.particleSystem, this.particleMaterial);
+        this.add(this.particles);
+        // Set initial position from options
+        if (this.options.emitterPosition) {
+            this.position.copy(this.options.emitterPosition);
+        }
+        // Set initial rotation from options
+        if (this.options.emitterRotation) {
+            this.rotation.copy(this.options.emitterRotation);
+        }
+    }
+    /**
+     * Create the particle material with texture support
+     */
+    createParticleMaterial() {
+        // Create material options
+        const materialOptions = {
+            color: this.options.particleColor,
+            size: this.options.particleSize,
+            blending: THREE.AdditiveBlending,
+            transparent: true,
+            sizeAttenuation: true,
+            depthWrite: false
+        };
+        // Add texture if available
+        if (this.particleTexture) {
+            materialOptions.map = this.particleTexture;
+        }
+        // Add alpha map if provided
+        if (this.options.particleAlphaMap) {
+            materialOptions.alphaMap = this.options.particleAlphaMap;
+        }
+        // Add alpha test if specified
+        if (this.options.particleAlphaTest !== undefined) {
+            materialOptions.alphaTest = this.options.particleAlphaTest;
+        }
+        // Create the material
+        this.particleMaterial = new THREE.PointsMaterial(materialOptions);
+    }
+    beginPlay() {
+        super.beginPlay();
+        // Register for tick updates
+        const actor = this.getActor();
+        if (actor) {
+            this.onTickPostPhysics.add((_, deltaTime) => this.updateParticles(deltaTime));
+        }
+    }
+    endPlay() {
+        super.endPlay();
+        // Clean up textures if needed
+        this.disposeTextures();
+    }
+    /**
+     * Dispose of any textures when the component is destroyed
+     */
+    disposeTextures() {
+        // Only dispose textures that we created internally
+        if (this.particleTexture && this.options.particleTextureUrl) {
+            this.particleTexture.dispose();
+        }
+    }
+    /**
+     * Generate a random position and velocity for a particle based on emission shape
+     * @returns Object containing position and velocity
+     */
+    generateEmissionVectors() {
+        const emissionShape = this.options.emissionShape ?? EmissionShape.Sphere;
+        const position = new THREE.Vector3(0, 0, 0);
+        let velocity = new THREE.Vector3();
+        switch (emissionShape) {
+            case EmissionShape.Sphere:
+                // Random direction in sphere (default behavior)
+                velocity = this.generateRandomSphereDirection();
+                break;
+            case EmissionShape.Cone:
+                // Random direction within a cone
+                velocity = this.generateRandomConeDirection();
+                break;
+            case EmissionShape.Disc:
+                // Position in a disc, velocity perpendicular to disc
+                position.copy(this.generateRandomDiscPosition());
+                velocity = this.emissionDirection.clone();
+                break;
+            case EmissionShape.Box:
+                // Random position within a box
+                position.copy(this.generateRandomBoxPosition());
+                velocity = this.emissionDirection.clone();
+                break;
+        }
+        // Scale velocity by particle speed
+        velocity.multiplyScalar(this.options.particleSpeed);
+        return { position, velocity };
+    }
+    /**
+     * Generate a random direction in a full sphere
+     */
+    generateRandomSphereDirection() {
+        return new THREE.Vector3((Math.random() - 0.5) * 2, (Math.random() - 0.5) * 2, (Math.random() - 0.5) * 2).normalize();
+    }
+    /**
+     * Generate a random direction within a cone
+     */
+    generateRandomConeDirection() {
+        // Default cone angle is 45 degrees if not specified
+        const coneAngleRadians = THREE.MathUtils.degToRad(this.options.emissionAngle ?? 45);
+        const cosAngle = Math.cos(coneAngleRadians);
+        // Generate a random direction on a sphere
+        const direction = this.generateRandomSphereDirection();
+        // Create a quaternion to rotate from up vector to emission direction
+        const rotationQuat = new THREE.Quaternion();
+        rotationQuat.setFromUnitVectors(new THREE.Vector3(0, 1, 0), this.emissionDirection);
+        // Random angle around the cone
+        const theta = Math.random() * Math.PI * 2;
+        // Random height on the cone (using cosAngle as the lower bound for z)
+        const z = Math.random() * (1 - cosAngle) + cosAngle;
+        // Calculate x and y on the cone base
+        const r = Math.sqrt(1 - z * z);
+        const x = r * Math.cos(theta);
+        const y = r * Math.sin(theta);
+        // Create the direction vector and rotate it to align with emission direction
+        const coneDirection = new THREE.Vector3(x, y, z).normalize();
+        coneDirection.applyQuaternion(rotationQuat);
+        return coneDirection;
+    }
+    /**
+     * Generate a random position on a disc
+     */
+    generateRandomDiscPosition() {
+        const radius = this.options.emissionRadius ?? 1.0;
+        const angle = Math.random() * Math.PI * 2;
+        const distance = Math.sqrt(Math.random()) * radius; // sqrt gives uniform distribution
+        // Calculate position on a disc in the XZ plane
+        const x = distance * Math.cos(angle);
+        const z = distance * Math.sin(angle);
+        // Create perpendicular axes to the emission direction
+        const up = this.emissionDirection.clone().normalize();
+        const right = new THREE.Vector3(0, 1, 0).cross(up).normalize();
+        if (right.lengthSq() < 0.001) {
+            right.set(1, 0, 0); // Fallback if emission direction is parallel to up
+        }
+        const forward = up.clone().cross(right).normalize();
+        // Position on the disc oriented perpendicular to emission direction
+        const position = new THREE.Vector3();
+        position.addScaledVector(right, x);
+        position.addScaledVector(forward, z);
+        return position;
+    }
+    /**
+     * Generate a random position within a box
+     */
+    generateRandomBoxPosition() {
+        const dimensions = this.options.emissionDimensions ?? new THREE.Vector3(1, 1, 1);
+        // Random position within the box, centered at origin
+        const position = new THREE.Vector3((Math.random() - 0.5) * dimensions.x, (Math.random() - 0.5) * dimensions.y, (Math.random() - 0.5) * dimensions.z);
+        return position;
+    }
+    emitSingleParticle(index) {
+        if (!this.particlePositions || !this.particleVelocities || !this.particleLifetimes) {
+            return;
+        }
+        // Generate position and velocity based on emission shape
+        const { position, velocity } = this.generateEmissionVectors();
+        // Set particle data
+        const baseIndex = index * 3;
+        // Set position based on emission shape
+        this.particlePositions[baseIndex] = position.x;
+        this.particlePositions[baseIndex + 1] = position.y;
+        this.particlePositions[baseIndex + 2] = position.z;
+        // Set velocity based on emission shape
+        this.particleVelocities[baseIndex] = velocity.x;
+        this.particleVelocities[baseIndex + 1] = velocity.y;
+        this.particleVelocities[baseIndex + 2] = velocity.z;
+        // Set lifetime
+        this.particleLifetimes[index] = this.options.particleLifetime;
+    }
+    emitParticle() {
+        if (!this.particlePositions || !this.particleVelocities || !this.particleLifetimes) {
+            return;
+        }
+        // Find an inactive particle
+        for (let i = 0; i < this.options.particleCount; i++) {
+            if (this.particleLifetimes[i] <= 0) {
+                this.emitSingleParticle(i);
+                // We found and updated a particle, so we're done
+                break;
+            }
+        }
+        // Mark attribute as needing update
+        if (this.positionAttribute) {
+            this.positionAttribute.needsUpdate = true;
+        }
+    }
+    updateParticles(deltaTime) {
+        if (!this.particlePositions || !this.particleVelocities || !this.particleLifetimes || !this.positionAttribute) {
+            return;
+        }
+        // Check if we should emit continuously or just once
+        const emitContinuously = this.options.emitContinuously ?? true;
+        // If we should emit just once and haven't done so yet, emit a burst
+        if (!emitContinuously && !this.hasEmittedOnce) {
+            this.hasEmittedOnce = true;
+        }
+        // Otherwise, if continuous emission is enabled, emit based on rate
+        else if (emitContinuously) {
+            // Emit particles based on rate
+            const emitterRate = this.options.emitterRate ?? 10; // Default to 10 particles per second
+            this.timeAccumulator += deltaTime;
+            const timeBetweenParticles = 1 / emitterRate;
+            while (this.timeAccumulator >= timeBetweenParticles) {
+                this.emitParticle();
+                this.timeAccumulator -= timeBetweenParticles;
+            }
+        }
+        // Update all active particles
+        let needsUpdate = false;
+        for (let i = 0; i < this.options.particleCount; i++) {
+            if (this.particleLifetimes[i] > 0) {
+                // Decrease lifetime
+                this.particleLifetimes[i] -= deltaTime;
+                // Update position based on velocity
+                const baseIndex = i * 3;
+                this.particlePositions[baseIndex] += this.particleVelocities[baseIndex] * deltaTime;
+                this.particlePositions[baseIndex + 1] += this.particleVelocities[baseIndex + 1] * deltaTime;
+                this.particlePositions[baseIndex + 2] += this.particleVelocities[baseIndex + 2] * deltaTime;
+                needsUpdate = true;
+            }
+        }
+        // Update the buffer geometry if needed
+        if (needsUpdate) {
+            this.positionAttribute.needsUpdate = true;
+        }
+    }
+    // Helper method to set emission rate
+    setEmissionRate(rate) {
+        this.options.emitterRate = rate;
+    }
+    // Helper method to set particle color
+    setParticleColor(color) {
+        if (this.particleMaterial) {
+            this.particleMaterial.color = color;
+        }
+        this.options.particleColor = color;
+    }
+    // Helper method to set particle size
+    setParticleSize(size) {
+        if (this.particleMaterial) {
+            this.particleMaterial.size = size;
+        }
+        this.options.particleSize = size;
+        // Update size attribute if it exists
+        if (this.sizeAttribute) {
+            const sizes = this.sizeAttribute.array;
+            for (let i = 0; i < this.options.particleCount; i++) {
+                sizes[i] = size;
+            }
+            this.sizeAttribute.needsUpdate = true;
+        }
+    }
+    // Helper method to set continuous emission mode
+    setEmitContinuously(continuous) {
+        this.options.emitContinuously = continuous;
+        // If switching from non-continuous to continuous, reset the hasEmittedOnce flag
+        if (continuous) {
+            this.hasEmittedOnce = false;
+        }
+    }
+    // Helper method to restart emission for one-time emitters
+    restart() {
+        this.hasEmittedOnce = false;
+    }
+    // Helper method to set emission direction
+    setEmissionDirection(direction) {
+        this.emissionDirection = direction.clone().normalize();
+        this.options.emissionDirection = this.emissionDirection.clone();
+    }
+    // Helper method to set emission shape
+    setEmissionShape(shape) {
+        this.options.emissionShape = shape;
+    }
+    // Helper method to set emission angle for cone shape
+    setEmissionAngle(angleDegrees) {
+        this.options.emissionAngle = angleDegrees;
+    }
+    // Helper method to set emission radius for disc or cone shape
+    setEmissionRadius(radius) {
+        this.options.emissionRadius = radius;
+    }
+    // Helper method to set emission dimensions for box shape
+    setEmissionDimensions(dimensions) {
+        this.options.emissionDimensions = dimensions.clone();
+    }
+    // Helper method to set particle speed
+    setParticleSpeed(speed) {
+        this.options.particleSpeed = speed;
+    }
+    // Helper method to set particle lifetime
+    setParticleLifetime(lifetime) {
+        this.options.particleLifetime = lifetime;
+    }
+    /**
+     * Set a texture for the particles from a URL
+     * @param url URL of the texture to load
+     */
+    async setParticleTexture(url) {
+        try {
+            // Load the texture
+            const texture = new UrlTexture({ url });
+            // Apply it to the material
+            if (this.particleMaterial) {
+                this.particleMaterial.map = texture;
+                this.particleMaterial.needsUpdate = true;
+            }
+            // Store in options
+            // Dispose old texture if we loaded it
+            if (this.particleTexture && this.options.particleTextureUrl) {
+                this.particleTexture.dispose();
+            }
+            this.options.particleTexture = texture;
+            this.options.particleTextureUrl = url;
+            this.particleTexture = texture;
+        }
+        catch (error) {
+            console.error('Failed to load particle texture:', error);
+        }
+    }
+    /**
+     * Set an existing texture for particles
+     * @param texture The texture to use
+     */
+    setParticleTextureObject(texture) {
+        if (this.particleMaterial) {
+            this.particleMaterial.map = texture;
+            this.particleMaterial.needsUpdate = true;
+        }
+        this.options.particleTexture = texture;
+        // Don't store a URL since this was passed as an object
+        this.options.particleTextureUrl = undefined;
+    }
+    /**
+     * Set the alpha test value for the particle material
+     * @param alphaTest Alpha test value (0.0-1.0)
+     */
+    setAlphaTest(alphaTest) {
+        if (this.particleMaterial) {
+            this.particleMaterial.alphaTest = alphaTest;
+            this.particleMaterial.needsUpdate = true;
+        }
+        this.options.particleAlphaTest = alphaTest;
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_ParticleEmitter';
+    }
+};
+Object.defineProperty(ParticleEmitterComponent, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        ...SceneComponent.EDITOR_CLASS_META,
+        emissionShape: { select: Object.values(EmissionShape) },
+    }
+});
+ParticleEmitterComponent = __decorate([
+    EngineClass('ParticleEmitterComponent'),
+    __metadata("design:paramtypes", [Object])
+], ParticleEmitterComponent);
+export { ParticleEmitterComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ParticleEmitterComponent.js","sourceRoot":"","sources":["../../../../src/components/visual/ParticleEmitterComponent.ts"],"names":[],"mappings":"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"}