@needle-tools/engine 2.40.0-pre → 2.41.0-pre

package/lib/engine-components/ParticleSystemModules.d.ts

@@ -1,60 +1,176 @@
 import * as THREE from "three";
+import { Object3D, Vector3 } from "three";
+import { RGBAColor } from "./js-extensions/RGBAColor";
+import { AnimationCurve } from "./AnimationCurve";
+import { Vec3 } from "../engine/engine_types";
+declare type Color4 = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+declare type ColorKey = {
+    time: number;
+    color: Color4;
+};
+declare type AlphaKey = {
+    time: number;
+    alpha: number;
+};
+export declare class Gradient {
+    alphaKeys: Array<AlphaKey>;
+    colorKeys: Array<ColorKey>;
+    get duration(): number;
+    evaluate(time: number, target: RGBAColor): RGBAColor;
+}
+export declare enum ParticleSystemCurveMode {
+    Constant = 0,
+    Curve = 1,
+    TwoCurves = 2,
+    TwoConstants = 3
+}
+export declare enum ParticleSystemGradientMode {
+    Color = 0,
+    Gradient = 1,
+    TwoColors = 2,
+    TwoGradients = 3,
+    RandomColor = 4
+}
+export declare enum ParticleSystemSimulationSpace {
+    Local = 0,
+    World = 1,
+    Custom = 2
+}
+export declare enum ParticleSystemShapeType {
+    Sphere = 0,
+    SphereShell = 1,
+    Hemisphere = 2,
+    HemisphereShell = 3,
+    Cone = 4,
+    Box = 5,
+    Mesh = 6,
+    ConeShell = 7,
+    ConeVolume = 8,
+    ConeVolumeShell = 9,
+    Circle = 10,
+    CircleEdge = 11,
+    SingleSidedEdge = 12,
+    MeshRenderer = 13,
+    SkinnedMeshRenderer = 14,
+    BoxShell = 15,
+    BoxEdge = 16,
+    Donut = 17,
+    Rectangle = 18,
+    Sprite = 19,
+    SpriteRenderer = 20
+}
+export declare class MinMaxCurve {
+    mode: ParticleSystemCurveMode;
+    constant: number;
+    constantMin: number;
+    constantMax: number;
+    curve?: AnimationCurve;
+    curveMin?: AnimationCurve;
+    curveMax?: AnimationCurve;
+    curveMultiplier?: number;
+    evaluate(t01: number, lerpFactor?: number): number;
+}
+export declare class MinMaxGradient {
+    mode: ParticleSystemGradientMode;
+    color: RGBAColor;
+    colorMin: RGBAColor;
+    colorMax: RGBAColor;
+    gradient: Gradient;
+    gradientMin: Gradient;
+    gradientMax: Gradient;
+    private _temp;
+    evaluate(t01: number, lerpFactor?: number): RGBAColor;
+}
+declare type ParticleSystemScalingMode = {
+    Hierarchy: number;
+    Local: number;
+    Shape: number;
+};
 export declare class MainModule {
-    randomizeRotationDirection: number;
+    cullingMode: number;
     duration: number;
+    emitterVelocityMode: number;
+    flipRotation: number;
+    gravityModifier: MinMaxCurve;
+    gravityModifierMultiplier: number;
     loop: boolean;
+    maxParticles: number;
+    playOnAwake: boolean;
     prewarm: boolean;
-    startDelay: undefined;
+    ringBufferLoopRange: {
+        x: number;
+        y: number;
+    };
+    ringBufferMode: boolean;
+    scalingMode: ParticleSystemScalingMode;
+    simulationSpace: ParticleSystemSimulationSpace;
+    simulationSpeed: number;
+    startColor: MinMaxGradient;
+    startDelay: MinMaxCurve;
     startDelayMultiplier: number;
-    startLifetime: undefined;
+    startLifetime: MinMaxCurve;
     startLifetimeMultiplier: number;
-    startSpeed: undefined;
-    startSpeedMultiplier: number;
+    startRotation: MinMaxCurve;
+    startRotationMultiplier: number;
+    startRotation3D: boolean;
+    startRotationX: MinMaxCurve;
+    startRotationXMultiplier: number;
+    startRotationY: MinMaxCurve;
+    startRotationYMultiplier: number;
+    startRotationZ: MinMaxCurve;
+    startRotationZMultiplier: number;
+    startSize: MinMaxCurve;
     startSize3D: boolean;
-    startSize: undefined;
     startSizeMultiplier: number;
-    startSizeX: undefined;
+    startSizeX: MinMaxCurve;
     startSizeXMultiplier: number;
-    startSizeY: undefined;
+    startSizeY: MinMaxCurve;
     startSizeYMultiplier: number;
-    startSizeZ: undefined;
+    startSizeZ: MinMaxCurve;
     startSizeZMultiplier: number;
-    startRotation3D: boolean;
-    startRotation: undefined;
-    startRotationMultiplier: number;
-    startRotationX: undefined;
-    startRotationXMultiplier: number;
-    startRotationY: undefined;
-    startRotationYMultiplier: number;
-    startRotationZ: undefined;
-    startRotationZMultiplier: number;
-    flipRotation: number;
-    startColor: THREE.Color;
-    startColor1: THREE.Color | undefined;
-    gravityModifier: undefined;
-    gravityModifierMultiplier: number;
-    simulationSpace: number;
-    customSimulationSpace: null;
-    simulationSpeed: number;
-    useUnscaledTime: boolean;
-    scalingMode: number;
-    playOnAwake: boolean;
-    maxParticles: number;
-    emitterVelocityMode: number;
+    startSpeed: MinMaxCurve;
+    startSpeedMultiplier: number;
     stopAction: number;
-    ringBufferMode: number;
-    ringBufferLoopRange: THREE.Vector2;
-    cullingMode: number;
+    useUnscaledTime: boolean;
 }
 export declare class EmissionModule {
     burstCount: number;
     enabled: boolean;
-    rate: number;
-    rateMutliplier: number;
-    rateOverDistance: number;
-    rateOverDistanceMultiplier: number;
-    rateOverTime: number;
+    rateOverTime: MinMaxCurve;
     rateOverTimeMultiplier: number;
+    rateOverDistance: MinMaxCurve;
+    rateOverDistanceMultiplier: number;
+    currentParticles: number;
+    maxParticles: number;
+    private _time;
+    private _summed;
+    /** called by nebula */
+    init(): void;
+    /** called by nebula */
+    getValue(deltaTime: number): number;
+}
+export declare class ColorOverLifetimeModule {
+    enabled: boolean;
+    color: MinMaxGradient;
+}
+export declare class SizeOverLifetimeModule {
+    enabled: boolean;
+    separateAxes: boolean;
+    size: MinMaxCurve;
+    sizeMultiplier: number;
+    sizeX: MinMaxCurve;
+    sizeXMultiplier: number;
+    sizeY: MinMaxCurve;
+    sizeYMultiplier: number;
+    sizeZ: MinMaxCurve;
+    sizeZMultiplier: number;
+    private _time;
+    evaluate(t01: number, target: Vec3): Vec3;
 }
 export declare class ShapeModule {
     shapeType: ParticleSystemShapeType;
@@ -63,31 +179,60 @@ export declare class ShapeModule {
     angle: number;
     arc: number;
     arcmode: number;
-    box: THREE.Vector3;
-    boxThickness: THREE.Vector3;
-    position: THREE.Vector3;
-    rotation: THREE.Vector3;
-    scale: THREE.Vector3;
+    boxThickness: Vector3;
+    position: Vector3;
+    rotation: Vector3;
+    scale: Vector3;
     radius: number;
+    radiusThickness: number;
     sphericalDirectionAmount: number;
+    private _space?;
+    private readonly _worldSpacePosition;
+    update(_context: Context, simulationSpace: ParticleSystemSimulationSpace, obj: Object3D): void;
+    /** nebula implementations: */
+    /** initializer implementation */
+    private _vector;
+    private _temp;
+    /** called by nebula on initialize */
+    get vector(): THREE.Vector3;
+    /** called by nebula */
+    getPosition(): void;
+    private _dir;
+    getDirection(position: any): Vec3;
 }
-export declare enum ParticleSystemShapeType {
-    Sphere = 0,
-    SphereShell = 1,
-    Hemisphere = 2,
-    HemisphereShell = 3,
-    Cone = 4,
-    Box = 5,
-    Mesh = 6,
-    ConeVolume = 7,
-    Circle = 10,
-    SingleSidedEdge = 11,
-    MeshRenderer = 12,
-    SkinnedMeshRenderer = 13,
-    BoxShell = 14,
-    BoxEdge = 15,
-    Donut = 16,
-    Rectangle = 17,
-    Sprite = 18,
-    SpriteRenderer = 19
+import { Context } from "../engine/engine_setup";
+export declare class NoiseModule {
+    damping: boolean;
+    enabled: boolean;
+    frequency: number;
+    octaveCount: number;
+    octaveMultiplier: number;
+    octaveScale: number;
+    positionAmount: MinMaxCurve;
+    quality: number;
+    remap: MinMaxCurve;
+    remapEnabled: boolean;
+    remapMultiplier: number;
+    remapX: MinMaxCurve;
+    remapXMultiplier: number;
+    remapY: MinMaxCurve;
+    remapYMultiplier: number;
+    remapZ: MinMaxCurve;
+    remapZMultiplier: number;
+    scrollSpeedMultiplier: number;
+    separateAxes: boolean;
+    strengthMultiplier: number;
+    strengthX: MinMaxCurve;
+    strengthXMultiplier: number;
+    strengthY: MinMaxCurve;
+    strengthYMultiplier: number;
+    strengthZ: MinMaxCurve;
+    strengthZMultiplier: number;
+    private _noise?;
+    private _time;
+    update(context: Context): void;
+    /** nebula implementations: */
+    private _temp;
+    applyNoise(index: number, pos: Vec3, vel: Vec3, deltaTime: number, age: number, life: number): void;
 }
+export {};