@galacean/engine-core 1.0.0-beta.9 → 1.0.1

package/types/particle/modules/MainModule.d.ts

@@ -0,0 +1,68 @@
+import { ICustomClone } from "../../clone/ComponentCloner";
+import { ParticleScaleMode } from "../enums/ParticleScaleMode";
+import { ParticleSimulationSpace } from "../enums/ParticleSimulationSpace";
+import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
+import { ParticleCompositeGradient } from "./ParticleCompositeGradient";
+export declare class MainModule implements ICustomClone {
+    private static _tempVector40;
+    private static _vector3One;
+    private static readonly _positionScale;
+    private static readonly _sizeScale;
+    private static readonly _worldPosition;
+    private static readonly _worldRotation;
+    private static readonly _gravity;
+    private static readonly _simulationSpace;
+    private static readonly _startRotation3D;
+    private static readonly _scaleMode;
+    /** The duration of the Particle Generator in seconds. */
+    duration: number;
+    /** Specifies whether the Particle Generator loops. */
+    isLoop: boolean;
+    /** Start delay in seconds. */
+    startDelay: ParticleCompositeCurve;
+    /** The initial lifetime of particles when emitted. */
+    startLifetime: ParticleCompositeCurve;
+    /** The initial speed of particles when the Particle Generator first spawns them. */
+    startSpeed: ParticleCompositeCurve;
+    /** A flag to enable specifying particle size individually for each axis. */
+    startSize3D: boolean;
+    /** The initial size of particles when the Particle Generator first spawns them. */
+    startSize: ParticleCompositeCurve;
+    /** The initial size of particles along the x-axis when the Particle Generator first spawns them. */
+    startSizeX: ParticleCompositeCurve;
+    /** The initial size of particles along the y-axis when the Particle Generator first spawns them. */
+    startSizeY: ParticleCompositeCurve;
+    /** The initial size of particles along the z-axis when the Particle Generator first spawns them. */
+    startSizeZ: ParticleCompositeCurve;
+    /** A flag to enable 3D particle rotation. */
+    startRotation3D: boolean;
+    /** The initial rotation of particles when the Particle Generator first spawns them. */
+    startRotation: ParticleCompositeCurve;
+    /** The initial rotation of particles around the x-axis when emitted.*/
+    startRotationX: ParticleCompositeCurve;
+    /** The initial rotation of particles around the y-axis when emitted. */
+    startRotationY: ParticleCompositeCurve;
+    startRotationZ: ParticleCompositeCurve;
+    /** Makes some particles spin in the opposite direction. */
+    flipRotation: number;
+    /** The mode of start color */
+    startColor: ParticleCompositeGradient;
+    /** A scale that this Particle Generator applies to gravity, defined by Physics.gravity. */
+    gravityModifier: ParticleCompositeCurve;
+    /** This selects the space in which to simulate particles. It can be either world or local space. */
+    simulationSpace: ParticleSimulationSpace;
+    /** Override the default playback speed of the Particle Generator. */
+    simulationSpeed: number;
+    /** Control how the Particle Generator applies its Transform component to the particles it emits. */
+    scalingMode: ParticleScaleMode;
+    /** If set to true, the Particle Generator automatically begins to play on startup. */
+    playOnEnabled: boolean;
+    private _maxParticles;
+    private _generator;
+    private _gravity;
+    /**
+     * Max particles count.
+     */
+    get maxParticles(): number;
+    set maxParticles(value: number);
+}

package/types/particle/modules/ParticleCompositeCurve.d.ts

@@ -0,0 +1,56 @@
+import { ParticleCurveMode } from "../enums/ParticleCurveMode";
+import { ParticleCurve } from "./ParticleCurve";
+/**
+ * Particle composite curve.
+ */
+export declare class ParticleCompositeCurve {
+    /** The curve mode. */
+    mode: ParticleCurveMode;
+    /** The min constant value used by the curve if mode is set to `TwoConstants`.*/
+    constantMin: number;
+    /** The max constant value used by the curve if mode is set to `TwoConstants`.*/
+    constantMax: number;
+    /** The min curve used by the curve if mode is set to `TwoCurves`. */
+    curveMin: ParticleCurve;
+    /** The max curve used by the curve if mode is set to `TwoCurves`. */
+    curveMax: ParticleCurve;
+    /**
+     * The constant value used by the curve if mode is set to `Constant`.
+     */
+    get constant(): number;
+    set constant(value: number);
+    /**
+     * The curve used by the curve if mode is set to `Curve`.
+     */
+    get curve(): ParticleCurve;
+    set curve(value: ParticleCurve);
+    /**
+     * Create a particle curve that generates a constant value.
+     * @param constant - The constant value
+     */
+    constructor(constant: number);
+    /**
+     * Create a particle curve that can generate values between a minimum constant and a maximum constant.
+     * @param constantMin - The min constant value
+     * @param constantMax - The max constant value
+     */
+    constructor(constantMin: number, constantMax: number);
+    /**
+     * Create a particle composite curve by a curve.
+     * @param curve - The curve
+     */
+    constructor(curve: ParticleCurve);
+    /**
+     * Create a particle composite curve by min and max curves.
+     * @param curveMin - The min curve
+     * @param curveMax - The max curve
+     */
+    constructor(curveMin: ParticleCurve, curveMax: ParticleCurve);
+    /**
+     * Query the value at the specified time.
+     * @param time - Normalized time at which to evaluate the curve, Valid when `mode` is set to `Curve` or `TwoCurves`
+     * @param lerpFactor - Lerp factor between two constants or curves, Valid when `mode` is set to `TwoConstants` or `TwoCurves`
+     * @returns - The result curve value
+     */
+    evaluate(time: number, lerpFactor: number): number;
+}

package/types/particle/modules/ParticleCompositeGradient.d.ts

@@ -0,0 +1,55 @@
+import { Color } from "@galacean/engine-math";
+import { ParticleGradientMode } from "../enums/ParticleGradientMode";
+import { ParticleGradient } from "./ParticleGradient";
+/**
+ * Particle composite gradient.
+ */
+export declare class ParticleCompositeGradient {
+    /** The gradient mode. */
+    mode: ParticleGradientMode;
+    constantMin: Color;
+    constantMax: Color;
+    /** The min gradient used by the gradient if mode is set to `Gradient`. */
+    gradientMin: ParticleGradient;
+    /** The max gradient used by the gradient if mode is set to `Gradient`. */
+    gradientMax: ParticleGradient;
+    /**
+     *  The constant color used by the gradient if mode is set to `Constant`.
+     */
+    get constant(): Color;
+    set constant(value: Color);
+    /**
+     * The gradient used by the gradient if mode is set to `Gradient`.
+     */
+    get gradient(): ParticleGradient;
+    set gradient(value: ParticleGradient);
+    /**
+     * Create a particle gradient that generates a constant color.
+     * @param constant - The constant color
+     */
+    constructor(constant: Color);
+    /**
+     * Create a particle gradient that can generate color between a minimum constant and a maximum constant.
+     * @param constantMin - The min constant color
+     * @param constantMax - The max constant color
+     */
+    constructor(constantMin: Color, constantMax: Color);
+    /**
+     * Create a particle gradient that generates a color from a gradient.
+     * @param gradient - The gradient
+     */
+    constructor(gradient: ParticleGradient);
+    /**
+     * Create a particle gradient that can generate color from a minimum gradient and a maximum gradient.
+     * @param gradientMin - The min gradient
+     *
+     */
+    constructor(gradientMin: ParticleGradient, gradientMax: ParticleGradient);
+    /**
+     * Query the color at the specified time.
+     * @param time - Normalized time at which to evaluate the gradient, Valid when `mode` is set to `Gradient` or `TwoGradients`
+     * @param lerpFactor - Lerp factor between two constants or gradients, Valid when `mode` is set to `TwoConstants` or `TwoGradients`
+     * @param out - The result color
+     */
+    evaluate(time: number, lerpFactor: number, out: Color): void;
+}

package/types/particle/modules/ParticleCurve.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Particle curve.
+ */
+export declare class ParticleCurve {
+    private _keys;
+    private _typeArray;
+    private _typeArrayDirty;
+    /**
+     * The keys of the curve.
+     */
+    get keys(): ReadonlyArray<CurveKey>;
+    /**
+     * Create a new particle curve.
+     * @param keys - The keys of the curve
+     */
+    constructor(...keys: CurveKey[]);
+    /**
+     * Add an key to the curve.
+     * @param key - The key
+     */
+    addKey(key: CurveKey): void;
+    /**
+     * Add an key to the curve.
+     * @param time - The key time
+     * @param value - The key value
+     */
+    addKey(time: number, value: number): void;
+    /**
+     * Remove a key from the curve.
+     * @param index - The remove key index
+     */
+    removeKey(index: number): void;
+    /**
+     * Set the keys of the curve.
+     * @param keys - The keys
+     */
+    setKeys(keys: CurveKey[]): void;
+    private _addKey;
+}
+/**
+ * The key of the curve.
+ */
+export declare class CurveKey {
+    /** The key time. */
+    time: number;
+    /** The key value. */
+    value: number;
+    /**
+     * Create a new key.
+     */
+    constructor(
+    /** The key time. */
+    time: number, 
+    /** The key value. */
+    value: number);
+}

package/types/particle/modules/ParticleGeneratorModule.d.ts

@@ -0,0 +1,12 @@
+import { ShaderData, ShaderMacro } from "../../shader";
+import { ParticleGenerator } from "../ParticleGenerator";
+/**
+ * Particle generator module.
+ */
+export declare abstract class ParticleGeneratorModule {
+    /** Specifies whether the module is enabled or not. */
+    enabled: boolean;
+    protected _generator: ParticleGenerator;
+    constructor(generator: ParticleGenerator);
+    protected _enableMacro(shaderData: ShaderData, lastEnableMacro: ShaderMacro, enableMacro: ShaderMacro): ShaderMacro;
+}

package/types/particle/modules/ParticleGradient.d.ts

@@ -0,0 +1,94 @@
+import { Color } from "@galacean/engine-math";
+/**
+ * Particle gradient.
+ */
+export declare class ParticleGradient {
+    private _colorKeys;
+    private _alphaKeys;
+    private _colorTypeArray;
+    private _alphaTypeArray;
+    private _colorTypeArrayDirty;
+    private _alphaTypeArrayDirty;
+    /**
+     * The color keys of the gradient.
+     */
+    get colorKeys(): ReadonlyArray<GradientColorKey>;
+    /**
+     * The alpha keys of the gradient.
+     */
+    get alphaKeys(): ReadonlyArray<GradientAlphaKey>;
+    /**
+     * Create a new particle gradient.
+     * @param colorKeys - The color keys of the gradient
+     * @param alphaKeys - The alpha keys of the gradient
+     */
+    constructor(colorKeys?: GradientColorKey[], alphaKeys?: GradientAlphaKey[]);
+    /**
+     * Add a color key to the gradient.
+     * @param key - The key
+     */
+    addColorKey(key: GradientColorKey): void;
+    /**
+     * Add a color key to the gradient.
+     * @param time - The key time
+     * @param color - The key color
+     */
+    addColorKey(time: number, color: Color): void;
+    /**
+     * Add an alpha key to the gradient.
+     * @param key - The key
+     */
+    addAlphaKey(key: GradientAlphaKey): void;
+    /**
+     * Add an alpha key to the gradient.
+     * @param time - The key time
+     * @param alpha - The key alpha
+     */
+    addAlphaKey(time: number, alpha: number): void;
+    /**
+     * Remove a color key from the gradient.
+     * @param index - The remove color key index
+     */
+    removeColorKey(index: number): void;
+    /**
+     * Remove an alpha key from the gradient.
+     * @param index - The remove alpha key index
+     */
+    removeAlphaKey(index: number): void;
+    /**
+     * Set the keys of the gradient.
+     * @param colorKeys - The color keys
+     * @param alphaKeys - The alpha keys
+     */
+    setKeys(colorKeys: GradientColorKey[], alphaKeys: GradientAlphaKey[]): void;
+    private _addKey;
+    private _removeKey;
+}
+/**
+ * The color key of the particle gradient.
+ */
+export declare class GradientColorKey {
+    /** The key time. */
+    time: number;
+    /** The key color. */
+    color: Color;
+    constructor(
+    /** The key time. */
+    time: number, 
+    /** The key color. */
+    color: Color);
+}
+/**
+ * The alpha key of the particle gradient.
+ */
+export declare class GradientAlphaKey {
+    /** The key time. */
+    time: number;
+    /** The key alpha. */
+    alpha: number;
+    constructor(
+    /** The key time. */
+    time: number, 
+    /** The key alpha. */
+    alpha: number);
+}

package/types/particle/modules/RotationOverLifetimeModule.d.ts

@@ -0,0 +1,34 @@
+import { ShaderMacro } from "../../shader/ShaderMacro";
+import { ShaderProperty } from "../../shader/ShaderProperty";
+import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
+import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
+/**
+ * Rotate particles throughout their lifetime.
+ */
+export declare class RotationOverLifetimeModule extends ParticleGeneratorModule {
+    static readonly _constantModeMacro: ShaderMacro;
+    static readonly _curveModeMacro: ShaderMacro;
+    static readonly _isSeparateMacro: ShaderMacro;
+    static readonly _isRandomTwoMacro: ShaderMacro;
+    static readonly _minConstantProperty: ShaderProperty;
+    static readonly _minCurveXProperty: ShaderProperty;
+    static readonly _minCurveYProperty: ShaderProperty;
+    static readonly _minCurveZProperty: ShaderProperty;
+    static readonly _maxConstantProperty: ShaderProperty;
+    static readonly _maxCurveXProperty: ShaderProperty;
+    static readonly _maxCurveYProperty: ShaderProperty;
+    static readonly _maxCurveZProperty: ShaderProperty;
+    /** Specifies whether the rotation is separate on each axis, when disabled only z axis is used. */
+    separateAxes: boolean;
+    /** Rotation over lifetime for z axis. */
+    rotationX: ParticleCompositeCurve;
+    /** Rotation over lifetime for z axis. */
+    rotationY: ParticleCompositeCurve;
+    /** Rotation over lifetime for z axis. */
+    rotationZ: ParticleCompositeCurve;
+    private _rotationMinConstant;
+    private _rotationMaxConstant;
+    private _enableSeparateMacro;
+    private _isCurveMacro;
+    private _isRandomTwoMacro;
+}

package/types/particle/modules/ShapeModule.d.ts

@@ -0,0 +1,9 @@
+import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
+import { BaseShape } from "./shape/BaseShape";
+/**
+ * Shape module of `ParticleGenerator`.
+ */
+export declare class ShapeModule extends ParticleGeneratorModule {
+    /** The shape of the emitter. */
+    shape: BaseShape;
+}

package/types/particle/modules/SizeOverLifetimeModule.d.ts

@@ -0,0 +1,34 @@
+import { ShaderMacro } from "../../shader/ShaderMacro";
+import { ShaderProperty } from "../../shader/ShaderProperty";
+import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
+import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
+/**
+ * Size over lifetime module.
+ */
+export declare class SizeOverLifetimeModule extends ParticleGeneratorModule {
+    static readonly _curveModeMacro: ShaderMacro;
+    static readonly _isSeparateMacro: ShaderMacro;
+    static readonly _isRandomTwoMacro: ShaderMacro;
+    static readonly _minCurveXProperty: ShaderProperty;
+    static readonly _minCurveYProperty: ShaderProperty;
+    static readonly _minCurveZProperty: ShaderProperty;
+    static readonly _maxCurveXProperty: ShaderProperty;
+    static readonly _maxCurveYProperty: ShaderProperty;
+    static readonly _maxCurveZProperty: ShaderProperty;
+    /** Specifies whether the Size is separate on each axis. */
+    separateAxes: boolean;
+    /** Size curve over lifetime for x axis. */
+    sizeX: ParticleCompositeCurve;
+    /** Size curve over lifetime for y axis. */
+    sizeY: ParticleCompositeCurve;
+    /** Size curve over lifetime for z axis. */
+    sizeZ: ParticleCompositeCurve;
+    private _enableSeparateMacro;
+    private _isCurveMacro;
+    private _isRandomTwoMacro;
+    /**
+     * Size curve over lifetime.
+     */
+    get size(): ParticleCompositeCurve;
+    set size(value: ParticleCompositeCurve);
+}

package/types/particle/modules/TextureSheetAnimationModule.d.ts

@@ -0,0 +1,42 @@
+import { Vector2 } from "@galacean/engine-math";
+import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
+import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
+/**
+ * Texture sheet animation module.
+ */
+export declare class TextureSheetAnimationModule extends ParticleGeneratorModule {
+    private static readonly _frameCurveMacro;
+    private static readonly _frameRandomCurvesMacro;
+    private static readonly _cycleCountProperty;
+    private static readonly _tillingParamsProperty;
+    private static readonly _frameMinCurveProperty;
+    private static readonly _frameMaxCurveProperty;
+    /** Start frame of the texture sheet. */
+    readonly startFrame: ParticleCompositeCurve;
+    /** Frame over time curve of the texture sheet. */
+    readonly frameOverTime: ParticleCompositeCurve;
+    /** Texture sheet animation type. */
+    type: TextureSheetAnimationType;
+    /** Cycle count. */
+    cycleCount: number;
+    private _tiling;
+    private _textureSheetMacro;
+    /**
+     * Tiling of the texture sheet.
+     * */
+    get tiling(): Vector2;
+    set tiling(value: Vector2);
+    /**
+     * @inheritDoc
+     */
+    cloneTo(dest: TextureSheetAnimationModule): void;
+}
+/**
+ * Texture sheet animation type.
+ */
+export declare enum TextureSheetAnimationType {
+    /** Animate over the whole texture sheet from left to right, top to bottom. */
+    WholeSheet = 0,
+    /** Animate a single row in the sheet from left to right. */
+    SingleRow = 1
+}

package/types/particle/modules/VelocityOverLifetimeModule.d.ts

@@ -0,0 +1,34 @@
+import { ShaderMacro } from "../../shader";
+import { ShaderProperty } from "../../shader/ShaderProperty";
+import { ParticleSimulationSpace } from "../enums/ParticleSimulationSpace";
+import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
+import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
+/**
+ * Velocity over lifetime module.
+ */
+export declare class VelocityOverLifetimeModule extends ParticleGeneratorModule {
+    static readonly _constantMacro: ShaderMacro;
+    static readonly _curveMacro: ShaderMacro;
+    static readonly _randomConstantMacro: ShaderMacro;
+    static readonly _randomCurveMacro: ShaderMacro;
+    static readonly _minConstantProperty: ShaderProperty;
+    static readonly _maxConstantProperty: ShaderProperty;
+    static readonly _minGradientXProperty: ShaderProperty;
+    static readonly _minGradientYProperty: ShaderProperty;
+    static readonly _minGradientZProperty: ShaderProperty;
+    static readonly _maxGradientXProperty: ShaderProperty;
+    static readonly _maxGradientYProperty: ShaderProperty;
+    static readonly _maxGradientZProperty: ShaderProperty;
+    static readonly _spaceProperty: ShaderProperty;
+    /** Velocity over lifetime for x axis. */
+    velocityX: ParticleCompositeCurve;
+    /** Velocity over lifetime for z axis. */
+    velocityY: ParticleCompositeCurve;
+    /** Velocity over lifetime for z axis. */
+    velocityZ: ParticleCompositeCurve;
+    /** Velocity space. */
+    space: ParticleSimulationSpace;
+    private _velocityMinConstant;
+    private _velocityMaxConstant;
+    private _velocityMacro;
+}

package/types/particle/modules/shape/BaseShape.d.ts

@@ -0,0 +1,12 @@
+import { ParticleShapeType } from "./enums/ParticleShapeType";
+/**
+ * Base class for all particle shapes.
+ */
+export declare abstract class BaseShape {
+    /** The type of shape to emit particles from. */
+    shapeType: ParticleShapeType;
+    /** Specifies whether the ShapeModule is enabled or disabled. */
+    enable: boolean;
+    /** Randomizes the starting direction of particles. */
+    randomDirectionAmount: number;
+}

package/types/particle/modules/shape/BoxShape.d.ts

@@ -0,0 +1,11 @@
+import { Vector3 } from "@galacean/engine-math";
+import { BaseShape } from "./BaseShape";
+/**
+ * Particle shape that emits particles from a box.
+ */
+export declare class BoxShape extends BaseShape {
+    private static _tempVector30;
+    /** The size of the box. */
+    size: Vector3;
+    constructor();
+}

package/types/particle/modules/shape/CircleShape.d.ts

@@ -0,0 +1,17 @@
+import { BaseShape } from "./BaseShape";
+import { ParticleShapeArcMode } from "./enums/ParticleShapeArcMode";
+/**
+ * Particle shape that emits particles from a circle.
+ */
+export declare class CircleShape extends BaseShape {
+    private static _tempPositionPoint;
+    /** Radius of the shape to emit particles from. */
+    radius: number;
+    /** Angle of the circle arc to emit particles from. */
+    arc: number;
+    /** The mode to generate particles around the arc. */
+    arcMode: ParticleShapeArcMode;
+    /** The speed of complete 360 degree rotation. */
+    arcSpeed: number;
+    constructor();
+}

package/types/particle/modules/shape/ConeShape.d.ts

@@ -0,0 +1,28 @@
+import { BaseShape } from "./BaseShape";
+/**
+ * Cone shape.
+ */
+export declare class ConeShape extends BaseShape {
+    private static _tempVector20;
+    private static _tempVector21;
+    private static _tempVector30;
+    private static _tempVector31;
+    /** Angle of the cone to emit particles from. */
+    angle: number;
+    /** Radius of the shape to emit particles from. */
+    radius: number;
+    /** Length of the cone to emit particles from. */
+    length: number;
+    /** Cone emitter type. */
+    emitType: ConeEmitType;
+    constructor();
+}
+/**
+ * Cone emitter type.
+ */
+export declare enum ConeEmitType {
+    /** Emit particles from the base of the cone. */
+    Base = 0,
+    /** Emit particles from the volume of the cone. */
+    Volume = 1
+}

package/types/particle/modules/shape/HemisphereShape.d.ts

@@ -0,0 +1,9 @@
+import { BaseShape } from "./BaseShape";
+/**
+ * Particle shape that emits particles from a hemisphere.
+ */
+export declare class HemisphereShape extends BaseShape {
+    /** Radius of the shape to emit particles from. */
+    radius: number;
+    constructor();
+}

package/types/particle/modules/shape/ShapeUtils.d.ts

@@ -0,0 +1 @@
+export {};

package/types/particle/modules/shape/SphereShape.d.ts

@@ -0,0 +1,9 @@
+import { BaseShape } from "./BaseShape";
+/**
+ * Particle shape that emits particles from a sphere.
+ */
+export declare class SphereShape extends BaseShape {
+    /** Radius of the shape to emit particles from. */
+    radius: number;
+    constructor();
+}

package/types/particle/modules/shape/enums/ParticleShapeArcMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Particle shape multi mode value.
+ */
+export declare enum ParticleShapeArcMode {
+    /** Generate points randomly. */
+    Random = 0,
+    /** Animate the emission point around the shape. */
+    Loop = 1
+}

package/types/particle/modules/shape/enums/ParticleShapeMultiModeValue.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The mode used to generate new points in a shape.
+ */
+export declare enum ParticleShapeMultiModeValue {
+    /** Generate points randomly. (Default) */
+    Random = 0,
+    /** Animate the emission point around the shape. */
+    Loop = 1
+}

package/types/particle/modules/shape/enums/ParticleShapeType.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The emission shape.
+ */
+export declare enum ParticleShapeType {
+    /** Emit from the volume of a box. */
+    Box = 0,
+    /** Emit from a circle. */
+    Circle = 1,
+    /** Emit from the base of a cone. */
+    Cone = 2,
+    /** Emit from a half-sphere. */
+    Hemisphere = 3,
+    /** Emit from a sphere. */
+    Sphere = 4
+}

package/types/particle/modules/shape/index.d.ts

@@ -0,0 +1,6 @@
+export { BoxShape } from "./BoxShape";
+export { CircleShape } from "./CircleShape";
+export { ConeShape, ConeEmitType } from "./ConeShape";
+export { HemisphereShape } from "./HemisphereShape";
+export { SphereShape } from "./SphereShape";
+export { ParticleShapeArcMode } from "./enums/ParticleShapeArcMode";