import { ShaderMacro } from "../../shader";
import { ShaderProperty } from "../../shader/ShaderProperty";
import { ParticleSimulationSpace } from "../enums/ParticleSimulationSpace";
import { ParticleGenerator } from "../ParticleGenerator";
import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
/**
 * Limit velocity over lifetime module.
 */
export declare class LimitVelocityOverLifetimeModule extends ParticleGeneratorModule {
    static readonly _enabledMacro: ShaderMacro;
    static readonly _separateAxesMacro: ShaderMacro;
    static readonly _speedConstantModeMacro: ShaderMacro;
    static readonly _speedCurveModeMacro: ShaderMacro;
    static readonly _speedIsRandomMacro: ShaderMacro;
    static readonly _dragCurveModeMacro: ShaderMacro;
    static readonly _dragIsRandomMacro: ShaderMacro;
    static readonly _multiplyDragBySizeMacro: ShaderMacro;
    static readonly _multiplyDragByVelocityMacro: ShaderMacro;
    static readonly _speedMaxConstProperty: ShaderProperty;
    static readonly _speedMinConstProperty: ShaderProperty;
    static readonly _speedMaxCurveProperty: ShaderProperty;
    static readonly _speedMinCurveProperty: ShaderProperty;
    static readonly _speedMaxConstVecProperty: ShaderProperty;
    static readonly _speedMinConstVecProperty: ShaderProperty;
    static readonly _speedXMaxCurveProperty: ShaderProperty;
    static readonly _speedXMinCurveProperty: ShaderProperty;
    static readonly _speedYMaxCurveProperty: ShaderProperty;
    static readonly _speedYMinCurveProperty: ShaderProperty;
    static readonly _speedZMaxCurveProperty: ShaderProperty;
    static readonly _speedZMinCurveProperty: ShaderProperty;
    static readonly _dampenProperty: ShaderProperty;
    static readonly _dragConstantProperty: ShaderProperty;
    static readonly _dragMaxCurveProperty: ShaderProperty;
    static readonly _dragMinCurveProperty: ShaderProperty;
    static readonly _spaceProperty: ShaderProperty;
    private _speedMinConstantVec;
    private _speedMaxConstantVec;
    private _dragConstantVec;
    private _enabledModuleMacro;
    private _separateAxesCachedMacro;
    private _speedModeMacro;
    private _speedRandomMacro;
    private _dragCurveCachedMacro;
    private _dragRandomCachedMacro;
    private _dragSizeMacro;
    private _dragVelocityMacro;
    private _separateAxes;
    private _speedX;
    private _speedY;
    private _speedZ;
    private _dampen;
    private _drag;
    private _multiplyDragByParticleSize;
    private _multiplyDragByParticleVelocity;
    private _space;
    /**
     * Whether to limit velocity on each axis separately.
     */
    get separateAxes(): boolean;
    set separateAxes(value: boolean);
    /**
     * Speed limit when separateAxes is false.
     */
    get speed(): ParticleCompositeCurve;
    set speed(value: ParticleCompositeCurve);
    /**
     * Speed limit for the x-axis (or overall limit when separateAxes is false).
     */
    get speedX(): ParticleCompositeCurve;
    set speedX(value: ParticleCompositeCurve);
    /**
     * Speed limit for the y-axis.
     */
    get speedY(): ParticleCompositeCurve;
    set speedY(value: ParticleCompositeCurve);
    /**
     * Speed limit for the z-axis.
     */
    get speedZ(): ParticleCompositeCurve;
    set speedZ(value: ParticleCompositeCurve);
    /**
     * Controls how much the velocity is dampened when it exceeds the limit.
     * @remarks Value is clamped to [0, 1]. 0 means no damping, 1 means full damping.
     */
    get dampen(): number;
    set dampen(value: number);
    /**
     * Controls the amount of drag applied to particle velocities.
     */
    get drag(): ParticleCompositeCurve;
    set drag(value: ParticleCompositeCurve);
    /**
     * Adjust the amount of drag based on particle sizes.
     */
    get multiplyDragByParticleSize(): boolean;
    set multiplyDragByParticleSize(value: boolean);
    /**
     * Adjust the amount of drag based on particle speeds.
     */
    get multiplyDragByParticleVelocity(): boolean;
    set multiplyDragByParticleVelocity(value: boolean);
    /**
     * Specifies if the velocity limits are in local space or world space.
     * @remarks Only takes effect when 'separateAxes' is enabled.
     */
    get space(): ParticleSimulationSpace;
    set space(value: ParticleSimulationSpace);
    /**
     * Specifies whether the module is enabled.
     * @remarks This module requires WebGL2, On WebGL1, enabling will be silently ignored.
     */
    get enabled(): boolean;
    set enabled(value: boolean);
    constructor(generator: ParticleGenerator);
    private _uploadScalarSpeed;
    private _uploadSeparateAxisSpeeds;
    private _uploadDrag;
}
