sparcoon 0.7.3 → 0.9.1

package/dist/emitter/spawn/FXSpawnSphere.js

@@ -1,87 +0,0 @@
-import { MathUtils } from 'three';
-import { assertValidNonNegativeNumber, assertValidNumber } from '../../miscellaneous/asserts.js';
-import { BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z } from '../../miscellaneous/miscellaneous.js';
-import { FXSpawn } from './FXSpawn.js';
-
-/**
- * Spawns particles at random positions within a spherical shell
- *
- * @remarks
- * The `angle` parameter controls the polar spread from the equatorial plane:
- * - `0` - flat disk (XZ plane only)
- * - `Math.PI / 2` - full sphere
- * - Values in between produce a spherical band
- */
-class FXSpawnSphere extends FXSpawn {
-    /**
-     * @param innerRadius - Minimum spawn radius; must be non-negative. Defaults to `0`
-     * @param outerRadius - Maximum spawn radius; must be non-negative. Defaults to `1`
-     * @param angle - Polar half-angle from equatorial plane in radians. Defaults to `Math.PI / 2`
-     */
-    constructor(innerRadius = 0, outerRadius = 1, angle = Math.PI / 2) {
-        super();
-        /** @internal */
-        this.requiredProperties = { builtin: "Matrix4" };
-        this._private_innerRadiusInternal = innerRadius;
-        this._private_outerRadiusInternal = outerRadius;
-        this._private_angleInternal = angle;
-        assertValidNonNegativeNumber(innerRadius, "FXSpawnSphere.constructor.innerRadius");
-        assertValidNonNegativeNumber(outerRadius, "FXSpawnSphere.constructor.outerRadius");
-        assertValidNumber(angle, "FXSpawnSphere.constructor.angle");
-    }
-    /** Minimum spawn radius */
-    get innerRadius() {
-        return this._private_innerRadiusInternal;
-    }
-    /** Maximum spawn radius */
-    get outerRadius() {
-        return this._private_outerRadiusInternal;
-    }
-    /**
-     * Polar half-angle from the equatorial plane.
-     * - `0` - flat disk
-     * - `Math.PI / 2` - full sphere
-     */
-    get angle() {
-        return this._private_angleInternal;
-    }
-    set innerRadius(value) {
-        assertValidNonNegativeNumber(value, "FXSpawnSphere.innerRadius");
-        this._private_innerRadiusInternal = value;
-    }
-    set outerRadius(value) {
-        assertValidNonNegativeNumber(value, "FXSpawnSphere.outerRadius");
-        this._private_outerRadiusInternal = value;
-    }
-    set angle(value) {
-        assertValidNumber(value, "FXSpawnSphere.angle");
-        this._private_angleInternal = value;
-    }
-    /** @internal */
-    spawn(properties, instanceBegin, instanceEnd) {
-        const { builtin } = properties;
-        const { array, itemSize } = builtin;
-        const inner = this._private_innerRadiusInternal;
-        const outer = this._private_outerRadiusInternal;
-        const sinAngle = Math.sin(this._private_angleInternal);
-        // Volume-uniform radius sampling within the shell
-        const inner3 = inner * inner * inner;
-        const outer3 = outer * outer * outer;
-        for (let i = instanceBegin; i < instanceEnd; i++) {
-            // Uniform volume-weighted radius
-            const r = Math.cbrt(MathUtils.randFloat(inner3, outer3));
-            // Uniform sampling on spherical zone:
-            // cosTheta in [-sinAngle, sinAngle] gives latitude range [-angle, +angle]
-            const cosTheta = MathUtils.randFloat(-sinAngle, sinAngle);
-            const sinTheta = Math.sqrt(1 - cosTheta * cosTheta);
-            const phi = MathUtils.randFloat(0, Math.PI * 2);
-            const itemOffset = i * itemSize;
-            array[itemOffset + BUILTIN_OFFSET_POSITION_X] = r * sinTheta * Math.cos(phi);
-            array[itemOffset + BUILTIN_OFFSET_POSITION_Y] = r * cosTheta;
-            array[itemOffset + BUILTIN_OFFSET_POSITION_Z] = r * sinTheta * Math.sin(phi);
-        }
-        builtin.needsUpdate = true;
-    }
-}
-
-export { FXSpawnSphere };

package/dist/emitter/spawn/FXSpawnTorque.d.ts

@@ -1,17 +0,0 @@
-import type { FXRange, FXRangeConfig } from "../../miscellaneous/miscellaneous";
-import { FXSpawn } from "./FXSpawn";
-/**
- * Assigns a random initial angular velocity to each spawned particle
- */
-export declare class FXSpawnTorque extends FXSpawn<{
-    builtin: "Matrix4";
-}> {
-    private torqueInternal;
-    /**
-     * @param torque - Angular velocity range in radians/second. Defaults to `{ min: -Math.PI, max: Math.PI }`
-     */
-    constructor(torque?: FXRangeConfig);
-    /** Angular velocity range in radians/second */
-    get torque(): FXRange;
-    set torque(value: FXRangeConfig);
-}

package/dist/emitter/spawn/FXSpawnTorque.js

@@ -1,42 +0,0 @@
-import { MathUtils } from 'three';
-import { assertValidNumber } from '../../miscellaneous/asserts.js';
-import { resolveFXRangeConfig, BUILTIN_OFFSET_TORQUE } from '../../miscellaneous/miscellaneous.js';
-import { FXSpawn } from './FXSpawn.js';
-
-/**
- * Assigns a random initial angular velocity to each spawned particle
- */
-class FXSpawnTorque extends FXSpawn {
-    /**
-     * @param torque - Angular velocity range in radians/second. Defaults to `{ min: -Math.PI, max: Math.PI }`
-     */
-    constructor(torque = { min: -Math.PI, max: Math.PI }) {
-        super();
-        /** @internal */
-        this.requiredProperties = { builtin: "Matrix4" };
-        this._private_torqueInternal = resolveFXRangeConfig(torque);
-        assertValidNumber(this._private_torqueInternal.min, "FXSpawnTorque.constructor.torque.min");
-        assertValidNumber(this._private_torqueInternal.max, "FXSpawnTorque.constructor.torque.max");
-    }
-    /** Angular velocity range in radians/second */
-    get torque() {
-        return this._private_torqueInternal;
-    }
-    set torque(value) {
-        this._private_torqueInternal = resolveFXRangeConfig(value);
-        assertValidNumber(this._private_torqueInternal.min, "FXSpawnTorque.torque.min");
-        assertValidNumber(this._private_torqueInternal.max, "FXSpawnTorque.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 { FXSpawnTorque };

package/dist/emitter/spawn/FXSpawnVelocity.d.ts

@@ -1,29 +0,0 @@
-import { Vector3 } from "three";
-import type { FXRange, FXRangeConfig } from "../../miscellaneous/miscellaneous";
-import { FXSpawn } from "./FXSpawn";
-/**
- * Assigns a random initial velocity to each spawned particle within a cone around a direction axis
- */
-export declare class FXSpawnVelocity extends FXSpawn<{
-    builtin: "Matrix4";
-}> {
-    private angleInternal;
-    private magnitudeInternal;
-    private readonly directionInternal;
-    /**
-     * @param direction - Cone axis; normalized automatically. Defaults to `(0, 1, 0)`
-     * @param angle - Cone half-angle range in radians; `{ min: 0, max: 0 }` fires in a straight line.
-     * Defaults to `{ min: 0, max: Math.PI }`
-     * @param magnitude - Speed range in units/second. Defaults to `{ min: -1, max: 1 }`
-     */
-    constructor(direction?: Vector3, angle?: FXRangeConfig, magnitude?: FXRangeConfig);
-    /** Cone axis (always normalized) */
-    get direction(): Vector3;
-    /** Cone half-angle range in radians */
-    get angle(): FXRange;
-    /** Speed range in units/second */
-    get magnitude(): FXRange;
-    set direction(value: Vector3);
-    set angle(value: FXRangeConfig);
-    set magnitude(value: FXRangeConfig);
-}

package/dist/emitter/spawn/FXSpawnVelocity.js

@@ -1,91 +0,0 @@
-import { Vector3, MathUtils } from 'three';
-import { assertValidNumber } from '../../miscellaneous/asserts.js';
-import { resolveFXRangeConfig, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z } from '../../miscellaneous/miscellaneous.js';
-import { FXSpawn } from './FXSpawn.js';
-
-const TEMP_TANGENT = new Vector3();
-const TEMP_BITANGENT = new Vector3();
-const TEMP_VELOCITY = new Vector3();
-/**
- * Assigns a random initial velocity to each spawned particle within a cone around a direction axis
- */
-class FXSpawnVelocity extends FXSpawn {
-    /**
-     * @param direction - Cone axis; normalized automatically. Defaults to `(0, 1, 0)`
-     * @param angle - Cone half-angle range in radians; `{ min: 0, max: 0 }` fires in a straight line.
-     * Defaults to `{ min: 0, max: Math.PI }`
-     * @param magnitude - Speed range in units/second. Defaults to `{ min: -1, max: 1 }`
-     */
-    constructor(direction = new Vector3(0, 1, 0), angle = { min: 0, max: Math.PI }, magnitude = { min: -1, max: 1 }) {
-        super();
-        /** @internal */
-        this.requiredProperties = { builtin: "Matrix4" };
-        this._private_directionInternal = direction.clone().normalize();
-        this._private_angleInternal = resolveFXRangeConfig(angle);
-        this._private_magnitudeInternal = resolveFXRangeConfig(magnitude);
-        assertValidNumber(this._private_angleInternal.min, "FXSpawnVelocity.constructor.angle.min");
-        assertValidNumber(this._private_angleInternal.max, "FXSpawnVelocity.constructor.angle.max");
-        assertValidNumber(this._private_magnitudeInternal.min, "FXSpawnVelocity.constructor.magnitude.min");
-        assertValidNumber(this._private_magnitudeInternal.max, "FXSpawnVelocity.constructor.magnitude.max");
-    }
-    /** Cone axis (always normalized) */
-    get direction() {
-        return this._private_directionInternal;
-    }
-    /** Cone half-angle range in radians */
-    get angle() {
-        return this._private_angleInternal;
-    }
-    /** Speed range in units/second */
-    get magnitude() {
-        return this._private_magnitudeInternal;
-    }
-    set direction(value) {
-        this._private_directionInternal.copy(value).normalize();
-    }
-    set angle(value) {
-        this._private_angleInternal = resolveFXRangeConfig(value);
-        assertValidNumber(this._private_angleInternal.min, "FXSpawnVelocity.angle.min");
-        assertValidNumber(this._private_angleInternal.max, "FXSpawnVelocity.angle.max");
-    }
-    set magnitude(value) {
-        this._private_magnitudeInternal = resolveFXRangeConfig(value);
-        assertValidNumber(this._private_magnitudeInternal.min, "FXSpawnVelocity.magnitude.min");
-        assertValidNumber(this._private_magnitudeInternal.max, "FXSpawnVelocity.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;
-        const dir = this._private_directionInternal;
-        if (Math.abs(dir.y) < 0.999) {
-            TEMP_TANGENT.set(0, 1, 0).cross(dir).normalize();
-        }
-        else {
-            TEMP_TANGENT.set(1, 0, 0).cross(dir).normalize();
-        }
-        TEMP_BITANGENT.crossVectors(dir, TEMP_TANGENT);
-        const cosMin = Math.cos(angleMax);
-        const cosMax = Math.cos(angleMin);
-        for (let i = instanceBegin; i < instanceEnd; i++) {
-            const itemOffset = i * itemSize;
-            const cosTheta = MathUtils.lerp(cosMin, cosMax, Math.random());
-            const sinTheta = Math.sqrt(1 - cosTheta * cosTheta);
-            const phi = Math.random() * Math.PI * 2;
-            const magnitude = MathUtils.randFloat(magnitudeMin, magnitudeMax);
-            TEMP_VELOCITY.copy(dir)
-                .multiplyScalar(cosTheta)
-                .addScaledVector(TEMP_TANGENT, Math.cos(phi) * sinTheta)
-                .addScaledVector(TEMP_BITANGENT, Math.sin(phi) * sinTheta)
-                .multiplyScalar(magnitude);
-            array[itemOffset + BUILTIN_OFFSET_VELOCITY_X] = TEMP_VELOCITY.x;
-            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Y] = TEMP_VELOCITY.y;
-            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Z] = TEMP_VELOCITY.z;
-        }
-        builtin.needsUpdate = true;
-    }
-}
-
-export { FXSpawnVelocity };

package/dist/instancedParticle/FXInstancedParticle.Internal.d.ts

@@ -1,2 +0,0 @@
-import { InstancedBufferGeometry } from "three";
-export declare const INSTANCED_PARTICLE_GEOMETRY: InstancedBufferGeometry;

package/dist/instancedParticle/shared.d.ts

@@ -1,19 +0,0 @@
-import type { IUniform, ShaderMaterial } from "three";
-import { Matrix3, Matrix4, Texture, Vector2, Vector3, Vector4 } from "three";
-import { FXColor } from "../miscellaneous/color/FXColor";
-export type FXProperty = Texture | FXColor | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | number;
-export type FXPropertyName = "Texture" | "FXColor" | "Vector2" | "Vector3" | "Vector4" | "Matrix3" | "Matrix4" | "number";
-export type FXPropertyConstructor = typeof Texture | typeof FXColor | typeof Vector2 | typeof Vector3 | typeof Vector4 | typeof Matrix3 | typeof Matrix4 | NumberConstructor;
-export type FXPropertyCopyTo = FXColor | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4;
-export type FXPropertyCopyFrom = FXColor & Vector2 & Vector3 & Vector4 & Matrix3 & Matrix4;
-export interface GLTypeInfo {
-    glslTypeName: string;
-    bufferSize: number;
-    instantiable: boolean;
-}
-export interface GLProperty {
-    value: FXProperty;
-    glslTypeInfo: GLTypeInfo;
-}
-export declare function resolveGLSLTypeInfo(value: FXProperty | FXPropertyName | FXPropertyConstructor): GLTypeInfo;
-export declare function resolvePropertyUniform(name: string, material: ShaderMaterial): IUniform<FXProperty>;

package/dist/instancedParticle/shared.js

@@ -1,116 +0,0 @@
-import { Texture, Vector2, Vector3, Vector4, Matrix3, Matrix4 } from 'three';
-import { FXColor } from '../miscellaneous/color/FXColor.js';
-
-const GLSL_TYPE_INFO_FLOAT = Object.freeze({
-    glslTypeName: "float",
-    bufferSize: 1,
-    instantiable: true,
-});
-const GLSL_TYPE_INFO_SAMPLER2D = Object.freeze({
-    glslTypeName: "sampler2D",
-    bufferSize: -1,
-    instantiable: false,
-});
-const GLSL_TYPE_INFO_VEC2 = Object.freeze({
-    glslTypeName: "vec2",
-    bufferSize: 2,
-    instantiable: true,
-});
-const GLSL_TYPE_INFO_VEC3 = Object.freeze({
-    glslTypeName: "vec3",
-    bufferSize: 3,
-    instantiable: true,
-});
-const GLSL_TYPE_INFO_VEC4 = Object.freeze({
-    glslTypeName: "vec4",
-    bufferSize: 4,
-    instantiable: true,
-});
-const GLSL_TYPE_INFO_MAT3 = Object.freeze({
-    glslTypeName: "mat3",
-    bufferSize: 9,
-    instantiable: true,
-});
-const GLSL_TYPE_INFO_MAT4 = Object.freeze({
-    glslTypeName: "mat4",
-    bufferSize: 16,
-    instantiable: true,
-});
-function resolveGLSLTypeInfo(value) {
-    if (typeof value === "string") {
-        switch (value) {
-            case "number":
-                return GLSL_TYPE_INFO_FLOAT;
-            case "Texture":
-                return GLSL_TYPE_INFO_SAMPLER2D;
-            case "FXColor":
-                return GLSL_TYPE_INFO_VEC4;
-            case "Vector2":
-                return GLSL_TYPE_INFO_VEC2;
-            case "Vector3":
-                return GLSL_TYPE_INFO_VEC3;
-            case "Vector4":
-                return GLSL_TYPE_INFO_VEC4;
-            case "Matrix3":
-                return GLSL_TYPE_INFO_MAT3;
-            case "Matrix4":
-                return GLSL_TYPE_INFO_MAT4;
-            default:
-                throw new Error(`resolveGLSLTypeInfo.value: unsupported property type name`);
-        }
-    }
-    if (typeof value === "function") {
-        if (value === Number) {
-            return GLSL_TYPE_INFO_FLOAT;
-        }
-        if (value === Texture) {
-            return GLSL_TYPE_INFO_SAMPLER2D;
-        }
-        if (value === FXColor) {
-            return GLSL_TYPE_INFO_VEC4;
-        }
-        if (value === Vector2) {
-            return GLSL_TYPE_INFO_VEC2;
-        }
-        if (value === Vector3) {
-            return GLSL_TYPE_INFO_VEC3;
-        }
-        if (value === Vector4) {
-            return GLSL_TYPE_INFO_VEC4;
-        }
-        if (value === Matrix3) {
-            return GLSL_TYPE_INFO_MAT3;
-        }
-        if (value === Matrix4) {
-            return GLSL_TYPE_INFO_MAT4;
-        }
-        throw new Error(`resolveGLSLTypeInfo.value: unsupported property type constructor`);
-    }
-    if (typeof value === "number") {
-        return GLSL_TYPE_INFO_FLOAT;
-    }
-    if (value instanceof Texture) {
-        return GLSL_TYPE_INFO_SAMPLER2D;
-    }
-    if (value instanceof FXColor) {
-        return GLSL_TYPE_INFO_VEC4;
-    }
-    if (value instanceof Vector2) {
-        return GLSL_TYPE_INFO_VEC2;
-    }
-    if (value instanceof Vector3) {
-        return GLSL_TYPE_INFO_VEC3;
-    }
-    if (value instanceof Vector4) {
-        return GLSL_TYPE_INFO_VEC4;
-    }
-    if (value instanceof Matrix3) {
-        return GLSL_TYPE_INFO_MAT3;
-    }
-    if (value instanceof Matrix4) {
-        return GLSL_TYPE_INFO_MAT4;
-    }
-    throw new Error(`resolveGLSLTypeInfo.value: unsupported property type`);
-}
-
-export { resolveGLSLTypeInfo };

package/dist/materials/FXDiffuseMaterial/FXDiffuseMaterial.Internal.d.ts

@@ -1,24 +0,0 @@
-import { Color, MeshLambertMaterial } from "three";
-import type { GLTypeInfo } from "../../instancedParticle/shared";
-import type { FXNodeBlending } from "../../nodes/blending/FXNodeBlending";
-import { FXNodeColor } from "../../nodes/color/FXNodeColor";
-import type { FXNodeNormal } from "../../nodes/normal/FXNodeNormal";
-import { FXNodeTexture } from "../../nodes/texture/FXNodeTexture";
-import { FXBlending } from "../FXMaterial/FXMaterial";
-export interface FXScatterUniforms {
-    u_ScatterTint: {
-        value: Color;
-    };
-    u_ScatterPower: {
-        value: number;
-    };
-    u_ForwardScatterStrength: {
-        value: number;
-    };
-    u_BackScatterStrength: {
-        value: number;
-    };
-}
-export declare function buildFXDiffuseMaterial(varyings: Record<string, GLTypeInfo>, blending: FXBlending, useAlphaHashing: boolean, alphaTest: number, albedoNodes: readonly (FXNodeColor | FXNodeTexture | FXNodeBlending)[], normalNodes: readonly (FXNodeTexture | FXNodeNormal)[], emissionNodes: readonly (FXNodeColor | FXNodeTexture)[], scatterUniforms?: FXScatterUniforms, shadowSensitivity?: {
-    value: number;
-}): MeshLambertMaterial;