sparcoon 0.0.1

package/dist/spawnModules/FXSpawnRandomLifetime.d.ts

@@ -0,0 +1,20 @@
+import type { FXRange, FXRangeConfig } from "../miscellaneous/miscellaneous";
+import { FXSpawnModule } from "./FXSpawnModule";
+/**
+ * Assigns random lifetime to particles.
+ *
+ * Lifetime is chosen uniformly from the specified range. Age is set to 0.
+ */
+export declare class FXSpawnRandomLifetime extends FXSpawnModule<{
+    builtin: "Matrix4";
+}> {
+    private lifetimeInternal;
+    /**
+     * @param lifetime - Lifetime range in seconds. Accepts number, tuple, or range object
+     */
+    constructor(lifetime?: FXRangeConfig);
+    /** Lifetime range in seconds */
+    get lifetime(): FXRange;
+    /** Lifetime range in seconds */
+    set lifetime(value: FXRangeConfig);
+}

package/dist/spawnModules/FXSpawnRandomLifetime.js

@@ -0,0 +1,47 @@
+import { MathUtils } from 'three';
+import { assertValidPositiveNumber } from '../miscellaneous/asserts.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_LIFETIME, BUILTIN_OFFSET_AGE } from '../miscellaneous/miscellaneous.js';
+import { FXSpawnModule } from './FXSpawnModule.js';
+
+/**
+ * Assigns random lifetime to particles.
+ *
+ * Lifetime is chosen uniformly from the specified range. Age is set to 0.
+ */
+class FXSpawnRandomLifetime extends FXSpawnModule {
+    /**
+     * @param lifetime - Lifetime range in seconds. Accepts number, tuple, or range object
+     */
+    constructor(lifetime = { min: 4, max: 8 }) {
+        super();
+        /** @internal */
+        this.requiredProperties = { builtin: "Matrix4" };
+        this._private_lifetimeInternal = resolveFXRangeConfig(lifetime);
+        assertValidPositiveNumber(this._private_lifetimeInternal.min, "UISpawnRandomLifetime.constructor.lifetime.min");
+        assertValidPositiveNumber(this._private_lifetimeInternal.max, "UISpawnRandomLifetime.constructor.lifetime.max");
+    }
+    /** Lifetime range in seconds */
+    get lifetime() {
+        return this._private_lifetimeInternal;
+    }
+    /** Lifetime range in seconds */
+    set lifetime(value) {
+        this._private_lifetimeInternal = resolveFXRangeConfig(value);
+        assertValidPositiveNumber(this._private_lifetimeInternal.min, "UISpawnRandomLifetime.lifetime.min");
+        assertValidPositiveNumber(this._private_lifetimeInternal.max, "UISpawnRandomLifetime.lifetime.max");
+    }
+    /** @internal */
+    spawn(properties, instanceBegin, instanceEnd) {
+        const { builtin } = properties;
+        const { array, itemSize } = builtin;
+        const { min: lifetimeMin, max: lifetimeMax } = this._private_lifetimeInternal;
+        for (let i = instanceBegin; i < instanceEnd; i++) {
+            const itemOffset = i * itemSize;
+            array[itemOffset + BUILTIN_OFFSET_LIFETIME] = MathUtils.randFloat(lifetimeMin, lifetimeMax);
+            array[itemOffset + BUILTIN_OFFSET_AGE] = 0;
+        }
+        builtin.needsUpdate = true;
+    }
+}
+
+export { FXSpawnRandomLifetime };

package/dist/spawnModules/FXSpawnRandomRotation.d.ts

@@ -0,0 +1,20 @@
+import { type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
+import { FXSpawnModule } from "./FXSpawnModule";
+/**
+ * Assigns random rotation to particles.
+ *
+ * Initial rotation is chosen uniformly from the specified range.
+ */
+export declare class FXSpawnRandomRotation extends FXSpawnModule<{
+    builtin: "Matrix4";
+}> {
+    private rotationInternal;
+    /**
+     * @param rotation - Rotation range in radians. Accepts number, tuple, or range object
+     */
+    constructor(rotation?: FXRangeConfig);
+    /** Rotation range in radians */
+    get rotation(): FXRange;
+    /** Rotation range in radians */
+    set rotation(value: FXRangeConfig);
+}

package/dist/spawnModules/FXSpawnRandomRotation.js

@@ -0,0 +1,45 @@
+import { MathUtils } from 'three';
+import { assertValidNumber } from '../miscellaneous/asserts.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_ROTATION } from '../miscellaneous/miscellaneous.js';
+import { FXSpawnModule } from './FXSpawnModule.js';
+
+/**
+ * Assigns random rotation to particles.
+ *
+ * Initial rotation is chosen uniformly from the specified range.
+ */
+class FXSpawnRandomRotation extends FXSpawnModule {
+    /**
+     * @param rotation - Rotation range in radians. Accepts number, tuple, or range object
+     */
+    constructor(rotation = { min: -Math.PI, max: Math.PI }) {
+        super();
+        /** @internal */
+        this.requiredProperties = { builtin: "Matrix4" };
+        this._private_rotationInternal = resolveFXRangeConfig(rotation);
+        assertValidNumber(this._private_rotationInternal.min, "UISpawnRandomRotation.constructor.rotation.min");
+        assertValidNumber(this._private_rotationInternal.max, "UISpawnRandomRotation.constructor.rotation.max");
+    }
+    /** Rotation range in radians */
+    get rotation() {
+        return this._private_rotationInternal;
+    }
+    /** Rotation range in radians */
+    set rotation(value) {
+        this._private_rotationInternal = resolveFXRangeConfig(value);
+        assertValidNumber(this._private_rotationInternal.min, "UISpawnRandomRotation.rotation.min");
+        assertValidNumber(this._private_rotationInternal.max, "UISpawnRandomRotation.rotation.max");
+    }
+    /** @internal */
+    spawn(properties, instanceBegin, instanceEnd) {
+        const { builtin } = properties;
+        const { array, itemSize } = builtin;
+        const { min: rotationMin, max: rotationMax } = this._private_rotationInternal;
+        for (let i = instanceBegin; i < instanceEnd; i++) {
+            array[i * itemSize + BUILTIN_OFFSET_ROTATION] = MathUtils.randFloat(rotationMin, rotationMax);
+        }
+        builtin.needsUpdate = true;
+    }
+}
+
+export { FXSpawnRandomRotation };

package/dist/spawnModules/FXSpawnRandomScale.d.ts

@@ -0,0 +1,26 @@
+import { type FXAspectConfig, type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
+import { FXSpawnModule } from "./FXSpawnModule";
+/**
+ * Assigns random scale to particles.
+ *
+ * Base scale is chosen uniformly from the range. Aspect ratio is applied to X scale.
+ */
+export declare class FXSpawnRandomScale extends FXSpawnModule<{
+    builtin: "Matrix4";
+}> {
+    private scaleInternal;
+    private aspectInternal;
+    /**
+     * @param scale - Base scale range. Accepts number, tuple, or range object
+     * @param aspect - Width/height ratio. Accepts number or texture
+     */
+    constructor(scale?: FXRangeConfig, aspect?: FXAspectConfig);
+    /** Base scale range */
+    get scale(): FXRange;
+    /** Width/height aspect ratio */
+    get aspect(): number;
+    /** Base scale range */
+    set scale(value: FXRangeConfig);
+    /** Width/height aspect ratio */
+    set aspect(value: FXAspectConfig);
+}

package/dist/spawnModules/FXSpawnRandomScale.js

@@ -0,0 +1,60 @@
+import { MathUtils } from 'three';
+import { assertValidPositiveNumber } from '../miscellaneous/asserts.js';
+import { resolveFXRangeConfig, resolveAspect, BUILTIN_OFFSET_SCALE_X, BUILTIN_OFFSET_SCALE_Y } from '../miscellaneous/miscellaneous.js';
+import { FXSpawnModule } from './FXSpawnModule.js';
+
+/**
+ * Assigns random scale to particles.
+ *
+ * Base scale is chosen uniformly from the range. Aspect ratio is applied to X scale.
+ */
+class FXSpawnRandomScale extends FXSpawnModule {
+    /**
+     * @param scale - Base scale range. Accepts number, tuple, or range object
+     * @param aspect - Width/height ratio. Accepts number or texture
+     */
+    constructor(scale = { min: 50, max: 100 }, aspect = 1) {
+        super();
+        /** @internal */
+        this.requiredProperties = { builtin: "Matrix4" };
+        this._private_scaleInternal = resolveFXRangeConfig(scale);
+        this._private_aspectInternal = resolveAspect(aspect);
+        assertValidPositiveNumber(this._private_scaleInternal.min, "UISpawnRandomScale.constructor.scale.min");
+        assertValidPositiveNumber(this._private_scaleInternal.max, "UISpawnRandomScale.constructor.scale.max");
+        assertValidPositiveNumber(this._private_aspectInternal, "UISpawnRandomScale.constructor.aspect");
+    }
+    /** Base scale range */
+    get scale() {
+        return this._private_scaleInternal;
+    }
+    /** Width/height aspect ratio */
+    get aspect() {
+        return this._private_aspectInternal;
+    }
+    /** Base scale range */
+    set scale(value) {
+        this._private_scaleInternal = resolveFXRangeConfig(value);
+        assertValidPositiveNumber(this._private_scaleInternal.min, "UISpawnRandomScale.scale.min");
+        assertValidPositiveNumber(this._private_scaleInternal.max, "UISpawnRandomScale.scale.max");
+    }
+    /** Width/height aspect ratio */
+    set aspect(value) {
+        this._private_aspectInternal = resolveAspect(value);
+        assertValidPositiveNumber(this._private_aspectInternal, "UISpawnRandomScale.aspect");
+    }
+    /** @internal */
+    spawn(properties, instanceBegin, instanceEnd) {
+        const { builtin } = properties;
+        const { array, itemSize } = builtin;
+        const { min: scaleMin, max: scaleMax } = this._private_scaleInternal;
+        for (let i = instanceBegin; i < instanceEnd; i++) {
+            const itemOffset = i * itemSize;
+            const randomScale = MathUtils.randFloat(scaleMin, scaleMax);
+            array[itemOffset + BUILTIN_OFFSET_SCALE_X] = randomScale * this._private_aspectInternal;
+            array[itemOffset + BUILTIN_OFFSET_SCALE_Y] = randomScale;
+        }
+        builtin.needsUpdate = true;
+    }
+}
+
+export { FXSpawnRandomScale };

package/dist/spawnModules/FXSpawnRandomTorque.d.ts

@@ -0,0 +1,20 @@
+import { type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
+import { FXSpawnModule } from "./FXSpawnModule";
+/**
+ * Assigns random angular velocity to particles.
+ *
+ * Torque (rotation speed) is chosen uniformly from the specified range.
+ */
+export declare class FXSpawnRandomTorque extends FXSpawnModule<{
+    builtin: "Matrix4";
+}> {
+    private torqueInternal;
+    /**
+     * @param torque - Angular velocity range in radians/second. Accepts number, tuple, or range object
+     */
+    constructor(torque?: FXRangeConfig);
+    /** Angular velocity range in radians/second */
+    get torque(): FXRange;
+    /** Angular velocity range in radians/second */
+    set torque(value: FXRangeConfig);
+}

package/dist/spawnModules/FXSpawnRandomTorque.js

@@ -0,0 +1,45 @@
+import { MathUtils } from 'three';
+import { assertValidNumber } from '../miscellaneous/asserts.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_TORQUE } from '../miscellaneous/miscellaneous.js';
+import { FXSpawnModule } from './FXSpawnModule.js';
+
+/**
+ * Assigns random angular velocity to particles.
+ *
+ * Torque (rotation speed) is chosen uniformly from the specified range.
+ */
+class FXSpawnRandomTorque extends FXSpawnModule {
+    /**
+     * @param torque - Angular velocity range in radians/second. Accepts number, tuple, or range object
+     */
+    constructor(torque = { min: -Math.PI, max: Math.PI }) {
+        super();
+        /** @internal */
+        this.requiredProperties = { builtin: "Matrix4" };
+        this._private_torqueInternal = resolveFXRangeConfig(torque);
+        assertValidNumber(this._private_torqueInternal.min, "UISpawnRandomTorque.constructor.torque.min");
+        assertValidNumber(this._private_torqueInternal.max, "UISpawnRandomTorque.constructor.torque.max");
+    }
+    /** Angular velocity range in radians/second */
+    get torque() {
+        return this._private_torqueInternal;
+    }
+    /** Angular velocity range in radians/second */
+    set torque(value) {
+        this._private_torqueInternal = resolveFXRangeConfig(value);
+        assertValidNumber(this._private_torqueInternal.min, "UISpawnRandomTorque.torque.min");
+        assertValidNumber(this._private_torqueInternal.max, "UISpawnRandomTorque.torque.max");
+    }
+    /** @internal */
+    spawn(properties, instanceBegin, instanceEnd) {
+        const { builtin } = properties;
+        const { array, itemSize } = builtin;
+        const { min: torqueMin, max: torqueMax } = this._private_torqueInternal;
+        for (let i = instanceBegin; i < instanceEnd; i++) {
+            array[i * itemSize + BUILTIN_OFFSET_TORQUE] = MathUtils.randFloat(torqueMin, torqueMax);
+        }
+        builtin.needsUpdate = true;
+    }
+}
+
+export { FXSpawnRandomTorque };

package/dist/spawnModules/FXSpawnRandomVelocity.d.ts

@@ -0,0 +1,26 @@
+import { type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
+import { FXSpawnModule } from "./FXSpawnModule";
+/**
+ * Assigns random velocity to particles.
+ *
+ * Direction and magnitude are chosen independently from their respective ranges.
+ */
+export declare class FXSpawnRandomVelocity extends FXSpawnModule<{
+    builtin: "Matrix4";
+}> {
+    private angleInternal;
+    private magnitudeInternal;
+    /**
+     * @param angle - Direction range in radians. Accepts number, tuple, or range object
+     * @param magnitude - Speed range in units/second. Accepts number, tuple, or range object
+     */
+    constructor(angle?: FXRangeConfig, magnitude?: FXRangeConfig);
+    /** Direction range in radians */
+    get angle(): FXRange;
+    /** Speed range in units/second */
+    get magnitude(): FXRange;
+    /** Direction range in radians */
+    set angle(value: FXRangeConfig);
+    /** Speed range in units/second */
+    set magnitude(value: FXRangeConfig);
+}

package/dist/spawnModules/FXSpawnRandomVelocity.js

@@ -0,0 +1,64 @@
+import { MathUtils } from 'three';
+import { assertValidNumber } from '../miscellaneous/asserts.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y } from '../miscellaneous/miscellaneous.js';
+import { FXSpawnModule } from './FXSpawnModule.js';
+
+/**
+ * Assigns random velocity to particles.
+ *
+ * Direction and magnitude are chosen independently from their respective ranges.
+ */
+class FXSpawnRandomVelocity extends FXSpawnModule {
+    /**
+     * @param angle - Direction range in radians. Accepts number, tuple, or range object
+     * @param magnitude - Speed range in units/second. Accepts number, tuple, or range object
+     */
+    constructor(angle = { min: -Math.PI, max: Math.PI }, magnitude = { min: -50, max: 50 }) {
+        super();
+        /** @internal */
+        this.requiredProperties = { builtin: "Matrix4" };
+        this._private_angleInternal = resolveFXRangeConfig(angle);
+        this._private_magnitudeInternal = resolveFXRangeConfig(magnitude);
+        assertValidNumber(this._private_angleInternal.min, "UISpawnRandomVelocity.constructor.angle.min");
+        assertValidNumber(this._private_angleInternal.max, "UISpawnRandomVelocity.constructor.angle.max");
+        assertValidNumber(this._private_magnitudeInternal.min, "UISpawnRandomVelocity.constructor.magnitude.min");
+        assertValidNumber(this._private_magnitudeInternal.max, "UISpawnRandomVelocity.constructor.magnitude.max");
+    }
+    /** Direction range in radians */
+    get angle() {
+        return this._private_angleInternal;
+    }
+    /** Speed range in units/second */
+    get magnitude() {
+        return this._private_magnitudeInternal;
+    }
+    /** Direction range in radians */
+    set angle(value) {
+        this._private_angleInternal = resolveFXRangeConfig(value);
+        assertValidNumber(this._private_angleInternal.min, "UISpawnRandomVelocity.angle.min");
+        assertValidNumber(this._private_angleInternal.max, "UISpawnRandomVelocity.angle.max");
+    }
+    /** Speed range in units/second */
+    set magnitude(value) {
+        this._private_magnitudeInternal = resolveFXRangeConfig(value);
+        assertValidNumber(this._private_magnitudeInternal.min, "UISpawnRandomVelocity.magnitude.min");
+        assertValidNumber(this._private_magnitudeInternal.max, "UISpawnRandomVelocity.magnitude.max");
+    }
+    /** @internal */
+    spawn(properties, instanceBegin, instanceEnd) {
+        const { builtin } = properties;
+        const { array, itemSize } = builtin;
+        const { min: angleMin, max: angleMax } = this._private_angleInternal;
+        const { min: magnitudeMin, max: magnitudeMax } = this._private_magnitudeInternal;
+        for (let i = instanceBegin; i < instanceEnd; i++) {
+            const itemOffset = i * itemSize;
+            const angle = MathUtils.randFloat(angleMin, angleMax);
+            const magnitude = MathUtils.randFloat(magnitudeMin, magnitudeMax);
+            array[itemOffset + BUILTIN_OFFSET_VELOCITY_X] = Math.cos(angle) * magnitude;
+            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Y] = Math.sin(angle) * magnitude;
+        }
+        builtin.needsUpdate = true;
+    }
+}
+
+export { FXSpawnRandomVelocity };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "sparcoon",
+  "version": "0.0.1",
+  "description": "",
+  "keywords": [
+    "particles",
+    "three.js",
+    "mobile",
+    "ads",
+    "typescript"
+  ],
+  "author": "jango",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jango-git/sparcoon.git"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && rollup -c",
+    "prepublishOnly": "npm run build"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "peerDependencies": {
+    "three": ">=0.157.0 <0.180.0",
+    "ferrsign": "^0.0.4"
+  },
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@types/node": "^25.0.2",
+    "@types/three": "^0.157.0",
+    "@typescript-eslint/eslint-plugin": "^8.32.0",
+    "@typescript-eslint/parser": "^8.32.0",
+    "eslint": "^9.26.0",
+    "rollup": "^4.40.2",
+    "rollup-plugin-string": "^3.0.0",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "ts-transformer-minify-privates": "^1.0.0",
+    "typescript": "^5.8.3"
+  }
+}