import { Color, Matrix4, Object3D, Quaternion, Vector2, Vector3, Vector4 } from "three";
import type { EmitterShape, IParticleSystem as QParticleSystem, Particle, ShapeJSON, Vector3 as QVector3, Vector4 as QVector4 } from "three.quarks";
import { Context } from "../../engine/engine_setup.js";
import type { Vec2, Vec3 } from "../../engine/engine_types.js";
import { RGBAColor } from "../../engine/js-extensions/index.js";
import { AnimationCurve } from "../AnimationCurve.js";
import { MeshRenderer } from '../Renderer.js';
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 interface IParticleSystem {
    get currentParticles(): number;
    get maxParticles(): number;
    get time(): number;
    get deltaTime(): number;
    get duration(): number;
    readonly main: MainModule;
    get container(): Object3D;
    get worldspace(): boolean;
    get worldPos(): Vector3;
    get worldQuaternion(): Quaternion;
    get worldQuaternionInverted(): Quaternion;
    get worldScale(): Vector3;
    get matrixWorld(): Matrix4;
}
export declare enum ParticleSystemRenderMode {
    Billboard = 0,
    Stretch = 1,
    HorizontalBillboard = 2,
    VerticalBillboard = 3,
    Mesh = 4
}
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
}
declare type ParticleSystemCurveModeKeys = keyof typeof ParticleSystemCurveMode;
export declare enum ParticleSystemGradientMode {
    Color = 0,
    Gradient = 1,
    TwoColors = 2,
    TwoGradients = 3,
    RandomColor = 4
}
declare type ParticleSystemGradientModeKeys = keyof typeof ParticleSystemGradientMode;
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 enum ParticleSystemShapeMultiModeValue {
    Random = 0,
    Loop = 1,
    PingPong = 2,
    BurstSpread = 3
}
export declare class MinMaxCurve {
    static constant(val: number): MinMaxCurve;
    static betweenTwoConstants(min: number, max: number): MinMaxCurve;
    static curve(curve: AnimationCurve, multiplier?: number): MinMaxCurve;
    setConstant(val: number): void;
    setMinMaxConstant(min: number, max: number): void;
    setCurve(curve: AnimationCurve, multiplier?: number): void;
    mode: ParticleSystemCurveMode | ParticleSystemCurveModeKeys;
    constant: number;
    constantMin: number;
    constantMax: number;
    curve?: AnimationCurve;
    curveMin?: AnimationCurve;
    curveMax?: AnimationCurve;
    curveMultiplier?: number;
    clone(): MinMaxCurve;
    evaluate(t01: number, lerpFactor?: number): number;
    getMax(): number;
    private getMaxFromCurve;
}
export declare class MinMaxGradient {
    static constant(color: RGBAColor | Color): MinMaxGradient;
    static betweenTwoColors(color1: RGBAColor | Color, color2: RGBAColor | Color): MinMaxGradient;
    constant(color: RGBAColor | Color): this;
    betweenTwoColors(color1: RGBAColor | Color, color2: RGBAColor | Color): this;
    /**
     * The mode of the gradient, which can be Color, Gradient, TwoColors or TwoGradients.
     */
    mode: ParticleSystemGradientMode | ParticleSystemGradientModeKeys;
    color: RGBAColor | Color;
    colorMin: RGBAColor | Color;
    colorMax: RGBAColor | Color;
    gradient: Gradient;
    gradientMin: Gradient;
    gradientMax: Gradient;
    private static _temp;
    private static _temp2;
    evaluate(t01: number, lerpFactor?: number): RGBAColor | Color;
}
export declare enum ParticleSystemScalingMode {
    Hierarchy = 0,
    Local = 1,
    Shape = 2
}
export declare class MainModule {
    cullingMode: number;
    duration: number;
    emitterVelocityMode: number;
    flipRotation: number;
    gravityModifier: MinMaxCurve;
    gravityModifierMultiplier: number;
    loop: boolean;
    maxParticles: number;
    playOnAwake: boolean;
    prewarm: boolean;
    ringBufferLoopRange: {
        x: number;
        y: number;
    };
    ringBufferMode: boolean;
    scalingMode: ParticleSystemScalingMode;
    simulationSpace: ParticleSystemSimulationSpace;
    simulationSpeed: number;
    startColor: MinMaxGradient;
    startDelay: MinMaxCurve;
    startDelayMultiplier: number;
    startLifetime: MinMaxCurve;
    startLifetimeMultiplier: number;
    startRotation: MinMaxCurve;
    startRotationMultiplier: number;
    startRotation3D: boolean;
    startRotationX: MinMaxCurve;
    startRotationXMultiplier: number;
    startRotationY: MinMaxCurve;
    startRotationYMultiplier: number;
    startRotationZ: MinMaxCurve;
    startRotationZMultiplier: number;
    startSize: MinMaxCurve;
    startSize3D: boolean;
    startSizeMultiplier: number;
    startSizeX: MinMaxCurve;
    startSizeXMultiplier: number;
    startSizeY: MinMaxCurve;
    startSizeYMultiplier: number;
    startSizeZ: MinMaxCurve;
    startSizeZMultiplier: number;
    startSpeed: MinMaxCurve;
    startSpeedMultiplier: number;
    stopAction: number;
    useUnscaledTime: boolean;
}
export declare class ParticleBurst {
    cycleCount: number;
    maxCount: number;
    minCount: number;
    probability: number;
    repeatInterval: number;
    time: number;
    count: {
        constant: number;
        constantMax: number;
        constantMin: number;
        curve?: AnimationCurve;
        curveMax?: AnimationCurve;
        curveMin?: AnimationCurve;
        curveMultiplier?: number;
        mode: ParticleSystemCurveMode;
    };
    private _performed;
    reset(): void;
    run(time: number): number;
}
export declare class EmissionModule {
    enabled: boolean;
    get burstCount(): number;
    bursts: ParticleBurst[];
    rateOverTime: MinMaxCurve;
    rateOverTimeMultiplier: number;
    rateOverDistance: MinMaxCurve;
    rateOverDistanceMultiplier: number;
    /** set from system */
    system: IParticleSystem;
    reset(): void;
    getBurst(): number;
}
export declare class ColorOverLifetimeModule {
    enabled: boolean;
    color: MinMaxGradient;
}
export declare class SizeOverLifetimeModule {
    enabled: boolean;
    separateAxes: boolean;
    size: MinMaxCurve;
    sizeMultiplier: number;
    x: MinMaxCurve;
    xMultiplier: number;
    y: MinMaxCurve;
    yMultiplier: number;
    z: MinMaxCurve;
    zMultiplier: number;
    private _time;
    private _temp;
    evaluate(t01: number, target?: Vec3, lerpFactor?: number): Vec3;
}
export declare enum ParticleSystemMeshShapeType {
    Vertex = 0,
    Edge = 1,
    Triangle = 2
}
export declare class ShapeModule implements EmitterShape {
    get type(): string;
    initialize(particle: Particle): void;
    toJSON(): ShapeJSON;
    clone(): EmitterShape;
    shapeType: ParticleSystemShapeType;
    enabled: boolean;
    alignToDirection: boolean;
    angle: number;
    arc: number;
    arcSpread: number;
    arcSpeedMultiplier: number;
    arcMode: ParticleSystemShapeMultiModeValue;
    boxThickness: Vector3;
    position: Vector3;
    rotation: Vector3;
    private _rotation;
    scale: Vector3;
    radius: number;
    radiusThickness: number;
    sphericalDirectionAmount: number;
    randomDirectionAmount: number;
    randomPositionAmount: number;
    /** Controls if particles should spawn off vertices, faces or edges. `shapeType` must be set to `MeshRenderer` */
    meshShapeType?: ParticleSystemMeshShapeType;
    /** When assigned and `shapeType` is set to `MeshRenderer` particles will spawn using a mesh in the scene.
     * Use the `meshShapeType` to choose if particles should be spawned from vertices, faces or edges
     * To re-assign use the `setMesh` function to cache the mesh and geometry
     * */
    meshRenderer?: MeshRenderer;
    private _meshObj?;
    private _meshGeometry?;
    setMesh(mesh: MeshRenderer): void;
    private system;
    private _space?;
    private readonly _worldSpaceMatrix;
    private readonly _worldSpaceMatrixInverse;
    constructor();
    update(_system: QParticleSystem, _delta: number): void;
    onUpdate(system: IParticleSystem, _context: Context, simulationSpace: ParticleSystemSimulationSpace, obj: Object3D): void;
    private applyRotation;
    /** nebula implementations: */
    /** initializer implementation */
    private _vector;
    private _temp;
    private _triangle;
    onInitialize(particle: Particle): void;
    private _dir;
    getDirection(particle: Particle, pos: Vec3): Vector3;
    private static _randomQuat;
    private static _tempVec;
    private randomizePosition;
    private randomizeDirection;
    private spherizeDirection;
    private randomSpherePoint;
    private randomCirclePoint;
    private _loopTime;
    private _loopDirection;
    private randomConePoint;
}
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;
    apply(_index: number, pos: Vec3, vel: Vec3, _deltaTime: number, age: number, life: number): void;
}
export declare enum ParticleSystemTrailMode {
    PerParticle = 0,
    Ribbon = 1
}
export declare enum ParticleSystemTrailTextureMode {
    Stretch = 0,
    Tile = 1,
    DistributePerSegment = 2,
    RepeatPerSegment = 3
}
export declare class TrailModule {
    enabled: boolean;
    attachRibbonToTransform: boolean;
    colorOverLifetime: MinMaxGradient;
    colorOverTrail: MinMaxGradient;
    dieWithParticles: boolean;
    inheritParticleColor: boolean;
    lifetime: MinMaxCurve;
    lifetimeMultiplier: number;
    minVertexDistance: number;
    mode: ParticleSystemTrailMode;
    ratio: number;
    ribbonCount: number;
    shadowBias: number;
    sizeAffectsLifetime: boolean;
    sizeAffectsWidth: boolean;
    splitSubEmitterRibbons: boolean;
    textureMode: ParticleSystemTrailTextureMode;
    widthOverTrail: MinMaxCurve;
    widthOverTrailMultiplier: number;
    worldSpace: boolean;
    getWidth(size: number, _life01: number, pos01: number, t: number): number;
    getColor(color: Vector4 | QVector4, life01: number, pos01: number): void;
}
export declare class VelocityOverLifetimeModule {
    enabled: boolean;
    space: ParticleSystemSimulationSpace;
    orbitalX: MinMaxCurve;
    orbitalY: MinMaxCurve;
    orbitalZ: MinMaxCurve;
    orbitalXMultiplier: number;
    orbitalYMultiplier: number;
    orbitalZMultiplier: number;
    orbitalOffsetX: number;
    orbitalOffsetY: number;
    orbitalOffsetZ: number;
    speedModifier: MinMaxCurve;
    speedModifierMultiplier: number;
    x: MinMaxCurve;
    xMultiplier: number;
    y: MinMaxCurve;
    yMultiplier: number;
    z: MinMaxCurve;
    zMultiplier: number;
    private _system?;
    update(system: IParticleSystem): void;
    private _temp;
    private _temp2;
    private _temp3;
    private _hasOrbital;
    private _index;
    private _orbitalMatrix;
    init(particle: object): void;
    apply(_particle: object, _index: number, _pos: Vec3, vel: Vec3, _dt: number, age: number, life: number): void;
}
declare enum ParticleSystemAnimationTimeMode {
    Lifetime = 0,
    Speed = 1,
    FPS = 2
}
declare enum ParticleSystemAnimationRowMode {
    Custom = 0,
    Random = 1,
    MeshIndex = 2
}
declare enum ParticleSystemAnimationType {
    WholeSheet = 0,
    SingleRow = 1
}
export declare class TextureSheetAnimationModule {
    animation: ParticleSystemAnimationType;
    enabled: boolean;
    cycleCount: number;
    frameOverTime: MinMaxCurve;
    frameOverTimeMultiplier: number;
    numTilesX: number;
    numTilesY: number;
    startFrame: MinMaxCurve;
    startFrameMultiplier: number;
    rowMode: ParticleSystemAnimationRowMode;
    rowIndex: number;
    spriteCount: number;
    timeMode: ParticleSystemAnimationTimeMode;
    private sampleOnceAtStart;
    getStartIndex(): number;
    evaluate(t01: number): number | undefined;
    private getIndex;
}
export declare class RotationOverLifetimeModule {
    enabled: boolean;
    separateAxes: boolean;
    x: MinMaxCurve;
    xMultiplier: number;
    y: MinMaxCurve;
    yMultiplier: number;
    z: MinMaxCurve;
    zMultiplier: number;
    evaluate(t01: number, t: number): number;
}
export declare class RotationBySpeedModule {
    enabled: boolean;
    range: Vec2;
    separateAxes: boolean;
    x: MinMaxCurve;
    xMultiplier: number;
    y: MinMaxCurve;
    yMultiplier: number;
    z: MinMaxCurve;
    zMultiplier: number;
    evaluate(_t01: number, speed: number): number;
}
export declare class LimitVelocityOverLifetimeModule {
    enabled: boolean;
    dampen: number;
    drag: MinMaxCurve;
    dragMultiplier: number;
    limit: MinMaxCurve;
    limitMultiplier: number;
    separateAxes: boolean;
    limitX: MinMaxCurve;
    limitXMultiplier: number;
    limitY: MinMaxCurve;
    limitYMultiplier: number;
    limitZ: MinMaxCurve;
    limitZMultiplier: number;
    multiplyDragByParticleSize: boolean;
    multiplyDragByParticleVelocity: boolean;
    space: ParticleSystemSimulationSpace;
    private _temp;
    private _temp2;
    apply(_position: Vec3, baseVelocity: Vector3, currentVelocity: Vector3 | QVector3, _size: QVector3, t01: number, _dt: number, _scale: number): void;
}
export declare enum ParticleSystemInheritVelocityMode {
    Initial = 0,
    Current = 1
}
export declare class InheritVelocityModule {
    enabled: boolean;
    curve: MinMaxCurve;
    curveMultiplier: number;
    mode: ParticleSystemInheritVelocityMode;
    clone(): InheritVelocityModule;
    system: IParticleSystem;
    private get _lastWorldPosition();
    private get _velocity();
    private readonly _temp;
    private _firstUpdate;
    awake(system: IParticleSystem): void;
    reset(): void;
    update(_context: Context): void;
    applyInitial(vel: Vector3 | QVector3): void;
    private _frames;
    applyCurrent(vel: Vector3 | QVector3, t01: number, lerpFactor: number): void;
}
export declare class SizeBySpeedModule {
    enabled: boolean;
    range: Vector2;
    separateAxes: boolean;
    size: MinMaxCurve;
    sizeMultiplier: number;
    x: MinMaxCurve;
    xMultiplier: number;
    y: MinMaxCurve;
    yMultiplier: number;
    z: MinMaxCurve;
    zMultiplier: number;
    evaluate<T extends Vector3 | QVector3>(vel: T, _t01: number, lerpFactor: number, size: T): T;
}
export declare class ColorBySpeedModule {
    enabled: boolean;
    range: Vector2;
    color: MinMaxGradient;
    evaluate<T extends Vector3 | QVector3>(vel: T, lerpFactor: number, color: Vector4 | QVector4): void;
}
export {};