ParticleEmitter.yaml

name: ParticleEmitter
type: class
category: Effects
memory_category: Instances
summary: |
  A special object that emits customizable 2D particles into the world.
description: |
  A **ParticleEmitter** is a special object that emits customizable 2D particles
  into the world. To emit and render particles, it must be parented to a
  `Class.BasePart` or an `Class.Attachment` within such a part. When parented to
  a `Class.BasePart`, particles spawn randomly within the part's bounding box or
  [shape](../../../effects/particle-emitters.md#shape); when parented to an
  `Class.Attachment`, particles spawn from the attachment's position.

  Particles emit automatically when the emitter is
  `Class.ParticleEmitter.Enabled|Enabled` with a non-zero
  `Class.ParticleEmitter.Rate|Rate`, or manually when the
  `Class.ParticleEmitter:Emit()|Emit` method is called. With a non-zero
  `Class.ParticleEmitter.Speed|Speed`, particles are set in motion outwards
  and/or inwards, depending on the `Class.ParticleEmitter.ShapeInOut|ShapeInOut`
  property.

  By default, particles face the camera, but the
  `Class.ParticleEmitter.Orientation|Orientation` can be modified to respect the
  particle velocity instead.

  During the `Class.ParticleEmitter.Lifetime|Lifetime` of the particles, they
  can change appearance according to the `Class.ParticleEmitter.Color|Color` and
  `Class.ParticleEmitter.Size|Size`. Their motion can change over time according
  to the `Class.ParticleEmitter.Drag|Drag` and
  `Class.ParticleEmitter.Acceleration|Acceleration` properties, and they can
  also move as their parent moves when they are
  `Class.ParticleEmitter.LockedToPart|LockedToPart` or have a non-zero
  `Class.ParticleEmitter.VelocityInheritance|VelocityInheritance`.

  To learn more about creating and customizing particle emitters, see
  [Particle Emitters](../../../effects/particle-emitters.md).
code_samples:
  - Creating-A-ParticleEmitter-from-Scratch
inherits:
  - Instance
tags: []
deprecation_message: ''
properties:
  - name: ParticleEmitter.Acceleration
    summary: |
      Determines the global-axis acceleration of all active particles, measured
      in studs per second squared.
    description: |
      The **Acceleration** property determines how the
      `Class.ParticleEmitter.Speed|Speed` of particles changes over their
      lifetime. It is defined using a `Datatype.Vector3` to determine the
      acceleration on the global **X**/**Y**/**Z** axes and is measured in studs
      per second squared. When changed, this property affects all particles
      emitted by the emitter, both current and future.

      Acceleration will slow particles down if the vector points in the opposite
      `Class.ParticleEmitter.EmissionDirection|EmissionDirection` in which they
      are emitted. Otherwise, it will speed them up.
    code_samples:
    type: Vector3
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Motion
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Brightness
    summary: |
      Scales the light emitted from the emitter when
      `Class.ParticleEmitter.LightInfluence` is 0.
    description: |
      Scales the light emitted from the emitter when
      `Class.ParticleEmitter.LightInfluence` is 0.
    code_samples:
    type: float
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Appearance
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Color
    summary: |
      Determines the color of all active particles over their individual
      lifetimes.
    description: |
      The **Color** property determines the color of all active particles over
      their individual lifetimes. The color applies to the
      `Class.ParticleEmitter.Texture|Texture` when rendering and it uses the
      texture alpha along with the emitter's
      `Class.ParticleEmitter.Transparency|Transparency`. If an emitter has a
      `Class.ParticleEmitter.LightEmission|LightEmission` value that's greater
      than 0, darker colors make particles appear more transparent.

      Changing this property affects all particles emitted by the emitter, both
      current and future.

      When this property uses a gradient `Datatype.ColorSequence`, a particle's
      present color is determined by linearly interpolating on the sequence
      using the particle's age and its total lifetime. For example, if a
      particle spawned 2 seconds ago and has a 4 second lifetime, the color will
      be whatever is 50% of the way through the `Datatype.ColorSequence`.
    code_samples:
    type: ColorSequence
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Appearance
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Drag
    summary: |
      Determines the rate at which particles will lose half their speed through
      exponential decay.
    description: |
      The **Drag** property determines the rate in seconds at which individual
      particles will lose half their speed via exponential decay. Drag is
      applied by scaling the expected velocity from
      `Class.ParticleEmitter.Speed|Speed` and any velocity inherited from the
      parent from
      `Class.ParticleEmitter.VelocityInheritance|VelocityInheritance`. Setting
      this property to a negative value will cause particles' velocities to grow
      exponentially.
    code_samples:
    type: float
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Particles
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.EmissionDirection
    summary: |
      Determines the face of the object that particles emit from.
    description: |
      The **EmissionDirection** property determines the face (`Enum.NormalId`)
      of the parent object that particles emit from. A negative
      `Class.ParticleEmitter.Speed|Speed` means particles emit in the opposite
      direction. `Class.ParticleEmitter.SpreadAngle|SpreadAngle` further varies
      the emission direction.

      If you add a `Class.ParticleEmitter` to an `Class.Attachment`, which has a
      direction, you can rotate the attachment itself
      (`Class.Attachment.Orientation`) instead of using this property.
    code_samples:
    type: NormalId
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Emission
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Enabled
    summary: |
      Determines if particles emit from the emitter.
    description: |
      The **Enabled** property determines if particles emit from the emitter.
      Setting this to `false` stops further particles from spawning, but any
      existing particles remain active until they expire. This property is
      useful when you have a pre-made particle effect that you want to remain
      disabled until you need it to emit particles.

      If you want to clear all particles from a disabled emitter, call
      `Class.ParticleEmitter:Clear()|Clear()`. Then, if desired, call
      `Class.ParticleEmitter:Emit()|Emit()` on the emitter to emit and render
      particles.
    code_samples:
    type: bool
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Emission
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.FlipbookFramerate
    summary: |
      Determines how fast the flipbook texture animates in frames per second.
    description: |
      The **FlipbookFramerate** property determines how fast the flipbook
      texture animates in frames per second. Like
      `Class.ParticleEmitter.Lifetime|Lifetime`, you can set a minimum and
      maximum range to randomize the framerate of the flipbook, with a maximum
      of 30 frames per second.
    code_samples: []
    type: NumberRange
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Flipbook
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.FlipbookIncompatible
    summary: |
      The error message to display if the
      `Class.ParticleEmitter.Texture|Texture` is incompatible for a flipbook.
    description: |
      The error message to display if the
      `Class.ParticleEmitter.Texture|Texture` is incompatible for a flipbook.
      The flipbook texture must be of pixel dimensions 8×8, 16×16,
      32×32, 64×64, 128×128, 256×256, 512×512, or
      1024×1024.
    code_samples: []
    type: string
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Flipbook
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.FlipbookLayout
    summary: |
      Determines the layout of the flipbook texture. Must be None, Grid2x2,
      Grid4x4, or Grid8x8.
    description: |
      The **FlipbookLayout** property determines the layout of the texture. It
      can be any value of the `Enum.ParticleFlipbookLayout` enum:

      - **None** – Disable flipbook features and use the texture as a
        single static texture over the particle's lifetime.
      - **Grid2x2** – 2×2 frames for a 4-frame animation.
      - **Grid4x4** – 4×4 frames for a 16-frame animation.
      - **Grid8x8** – 8×8 frames for a 64-frame animation.
    code_samples: []
    type: ParticleFlipbookLayout
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Flipbook
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.FlipbookMode
    summary: |
      Determines the type of the flipbook animation. Must be Loop, OneShot,
      PingPong, or Random.
    description: |
      The **FlipbookMode** property determines the type of the flipbook
      animation. It can be any value of the `Enum.ParticleFlipbookMode` enum:

      - **Loop** – Continuously play through all frames, starting back at
        the first frame after playing the last.
      - **OneShot** – Play through the animation only once across the
        particle's lifetime. With this setting, the
        `Class.ParticleEmitter.FlipbookFramerate|FlipbookFramerate` property
        doesn't apply; instead, the framerate is determined by the particle's
        `Class.ParticleEmitter.Lifetime|Lifetime` divided evenly by the number
        of frames in the animation. **OneShot** animations are useful for clear
        non-repeating animations, such as an explosion that creates a puff of
        smoke and then fades out.
      - **PingPong** – Play from the first to the last frame, then in
        reverse from the last to the first, repeating throughout the
        `Class.ParticleEmitter.Lifetime|Lifetime` of the particle.
      - **Random** – Play the frames in a random order,
        blending/crossfading from one frame to the next. This can be useful for
        organic particle textures at low framerates, such as stars slowly
        twinkling between subtly different shapes.
    code_samples: []
    type: ParticleFlipbookMode
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Flipbook
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.FlipbookStartRandom
    summary: |
      Determines whether the animation starts at a random frame chosen per
      particle instead of always starting at frame zero.
    description: |
      The **FlipbookStartRandom** property determines whether each particle
      begins at a random frame of the animation instead of always starting at
      the first frame. One use case is to enable this property and also set
      `Class.ParticleEmitter.FlipbookFramerate|FlipbookFramerate` to zero,
      causing each emitted particle to be a static frame chosen randomly from
      the flipbook texture.
    code_samples: []
    type: bool
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Flipbook
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Lifetime
    summary: |
      Defines a random range of ages for newly emitted particles.
    description: |
      The **Lifetime** property defines the maximum and minimum ages for newly
      emitted particles. Lifetimes are stored on a per-particle basis, so if
      this value is changed, existing particles will stay active until their
      randomly chosen lifetime ends. A lifetime of 0 will prevent particles from
      emitting at all.
    code_samples:
    type: NumberRange
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Emission
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.LightEmission
    summary: |
      Determines how much particles' colors are blended with the colors behind
      them.
    description: |
      The **LightEmission** property determines the blending of the
      `Class.ParticleEmitter.Texture|Texture` colors with the colors behind
      them. A value of 0 uses normal blending mode while a value of 1 uses
      additive blending. When changed, this property instantly affects all
      particles owned by the emitter, both current and future.

      This property should not be confused with
      `Class.ParticleEmitter.LightInfluence|LightInfluence` which determines how
      particles are affected by environmental light.

      This property does **not** cause particles to light the environment around
      them. To accomplish that, consider using a `Class.PointLight`.
    code_samples:
    type: float
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Appearance
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.LightInfluence
    summary: |
      Determines how much particles are influenced by the environmental light.
    description: |
      The **LightInfluence** property determines how much environmental light
      affects the color of individual particles when they render. It must be in
      the range of 0–1; behavior of values outside of this range are not
      defined. At 0, particles are not influenced by light at all (they retain
      full brightness); at 1, particles are fully influenced by light (in
      complete darkness, particles will be black).

      By default, this value is 1 if inserted with Studio tools. If inserted
      using `Datatype.Instance.new()`, it is 0.
    code_samples:
    type: float
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Appearance
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.LocalTransparencyModifier
    summary: ''
    description: ''
    code_samples: []
    type: float
    tags:
      - Hidden
      - NotReplicated
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Appearance
    serialization:
      can_load: false
      can_save: false
  - name: ParticleEmitter.LockedToPart
    summary: |
      Determines whether the particles rigidly move with the part they're being
      emitted from.
    description: |
      The **LockedToPart** property determines if particles "stick" to the
      emission source (the `Class.Attachment` or `Class.BasePart` to which the
      `Class.ParticleEmitter` is parented). If `true`, active particles will
      move in lock step if the parent object moves.

      Alternatively, consider using the
      `Class.ParticleEmitter.VelocityInheritance|VelocityInheritance` property
      with a value of 1 which may be more appropriate for some effects.
    code_samples:
    type: bool
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Particles
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Orientation
    summary: |
      Specifies how to orient particles.
    description: |
      The **Orientation** property determines which orientation mode to use for
      an emitter's particle geometry.

      <table>
      <thead>
      <tr>
        <td>Orientation</td>
        <td>Particle Behavior</td>
      </tr>
      </thead>
      <tbody>
      <tr>
        <td><b>FacingCamera</b></td>
        <td>Standard camera-facing billboard quad; default behavior.</td>
      </tr>
      <tr>
        <td><b>FacingCameraWorldUp</b></td>
        <td>Facing the camera, but rotating only on the vertical upward world <b>Y</b> axis.</td>
      </tr>
      <tr>
        <td><b>VelocityParallel</b></td>
        <td>Aligned parallel to their direction of movement.</td>
      </tr>
      <tr>
        <td><b>VelocityPerpendicular</b></td>
        <td>Aligned perpendicular to their direction movement.</td>
      </tr>
      </tbody>
      </table>
    code_samples:
    type: ParticleOrientation
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Appearance
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Rate
    summary: |
      Determines the number of particles emitted per second.
    description: |
      The **Rate** property determines how many particles are emitted per second
      while the emitter is `Class.ParticleEmitter.Enabled|Enabled`. It is the
      inverse of frequency, meaning that a rate of 5 emits a particle every 0.2
      seconds. When changed, this property has no affect on any active
      particles.
    code_samples:
    type: float
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Emission
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.RotSpeed
    summary: |
      Determines the range of angular speeds of emitted particles, measured in
      degrees per second.
    description: |
      The **RotSpeed** property determines a random range of angular speeds for
      newly emitted particles, measured in degrees per second. A random angular
      speed is chosen upon emission, so changing this property doesn't affect
      active particles. This property, along with
      `Class.ParticleEmitter.Rotation|Rotation`, affects the angle of the
      rendered particle image.

      Particles with very high angular speeds can appear to rotate slower or not
      at all, since the angle of rotation is synchronized with the software
      render speed. For example, if particles rotate at exactly 360 degrees
      every frame, there will be no apparent change in rotation.
    code_samples:
    type: NumberRange
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Emission
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Rotation
    summary: |
      Determines the range of rotations in degrees for newly emitted particles.
    description: |
      The **Rotation** property determines the range of rotations in degrees for
      newly emitted particles, measured in degrees. Positive values are in the
      clockwise direction. This property is commonly set to `[0, 360]` to
      provide a completely random rotation to new particles.
      `Class.ParticleEmitter.RotSpeed|RotSpeed` also influences the rotation of
      a particle over its lifetime.

      Changes to this value only affect new particles; existing particles
      maintain the rotation at which they were originally emitted.
    code_samples:
    type: NumberRange
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Emission
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Shape
    summary: |
      Sets the shape of the emitter to either a box, sphere, cylinder, or disc.
    description: |
      The **Shape** property sets the shape of the emitter to either a box,
      sphere, cylinder, or disc. After you make a selection, you can adjust the
      `Class.ParticleEmitter.ShapeStyle|ShapeStyle`,
      `Class.ParticleEmitter.ShapeInOut|ShapeInOut`, and
      `Class.ParticleEmitter.ShapePartial|ShapePartial` properties to further
      customize particle emission. For visual examples, see
      [here](../../../effects/particle-emitters.md#shape).
    code_samples:
    type: ParticleEmitterShape
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: EmitterShape
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.ShapeInOut
    summary: |
      Sets whether particles emit outward only, inward only, or in both
      directions.
    description: |
      Sets whether particles emit outward only, inward only, or in both
      directions. For visual examples, see
      [here](../../../effects/particle-emitters.md#shape).
    code_samples:
    type: ParticleEmitterShapeInOut
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: EmitterShape
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.ShapePartial
    summary: |
      Influences particle emission from cylinder, disc, sphere, and box shapes.
    description: |
      Depending on the `Class.ParticleEmitter.Shape|Shape` value, this property
      performs a different action:

      - For cylinders, it specifies the top radius proportion. A value of 0
        means the top of the cylinder has zero radius, making it a cone. A value
        of 1 means the cylinder has no deformation.

      - For discs, it specifies the inner radius proportion. A value of 0 means
        the disc is fully closed (circle/ellipse), while a value of 1 means
        emission only occurs on the outermost rim of the disc. Values between 0
        and 1 emit from an annulus with a certain thickness.

      - For spheres, it specifies the hemispherical angle over which particles
        emit. A value of 1 means particles emit from the entire sphere; a value
        of 0.5 means particles emit from a half-dome; a value of 0 means
        particles only emit from a single point at the north pole.

      For visual examples, see
      [here](../../../effects/particle-emitters.md#shape).
    code_samples:
    type: float
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: EmitterShape
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.ShapeStyle
    summary: |
      Sets particle emission to either volumetric or surface-only emission.
    description: |
      Sets particle emission to either volumetric or surface-only emission. For
      visual examples, see [here](../../../effects/particle-emitters.md#shape).
    code_samples:
    type: ParticleEmitterShapeStyle
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: EmitterShape
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Size
    summary: |
      Determines the world size over individual particles' lifetimes.
    description: |
      The **Size** property determines the world size of all active particles
      over their individual lifetimes. This property represents the dimensions
      of the square `Class.ParticleEmitter.Texture|Texture` for each particle.
      It is a `Datatype.NumberSequence` that works similarly to
      `Class.ParticleEmitter.Transparency|Transparency`.

      A particle's present size is determined by linearly interpolating on this
      sequence using the particle's age and its total lifetime. For example, if
      a particle spawned 2 seconds ago and has a 4 second lifetime, the size
      will be whatever is 50% of the way through the `Datatype.NumberSequence`.
      For any `Datatype.NumberSequenceKeypoint` with a non-zero envelope value,
      a random value in the envelope range is chosen for each keypoint for each
      particle when it emits.
    code_samples:
    type: NumberSequence
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Appearance
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Speed
    summary: |
      Determines a random range of velocities (minimum to maximum) at which new
      particles will emit, measured in studs per second.
    description: |
      The **Speed** property determines a random range of velocities (minimum to
      maximum) at which new particles will emit, measured in studs per second.
      Each particle's velocity is chosen upon emission and it applies in the
      `Class.ParticleEmitter.EmissionDirection|EmissionDirection`. Negative
      values cause particles to travel in reverse.

      Note that changing `Class.ParticleEmitter.Speed|Speed` does not affect
      active particles and they retain whatever speed they already have.
      However, `Class.ParticleEmitter.Acceleration|Acceleration`,
      `Class.ParticleEmitter.Drag|Drag`, and
      `Class.ParticleEmitter.VelocityInheritance|VelocityInheritance` can be
      used to affect the speed of active particles over their lifetime.
    code_samples:
    type: NumberRange
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Emission
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.SpreadAngle
    summary: |
      Determines the angles at which particles may be randomly emit, measured in
      degrees.
    description: |
      The **SpreadAngle** property determines the random angles at which a
      particle may be emitted. For example, if the
      `Class.ParticleEmitter.EmissionDirection|EmissionDirection` is **Top**
      (+**Y**), this `Datatype.Vector2` describes the size of the random angle
      spread on the **X**/**Z** axes, in degrees.

      Setting one axis to 360 will cause particles to emit in all direction in a
      **circle**. Setting both to 360 will cause particles to emit in all
      directions in a **sphere**.
    code_samples:
    type: Vector2
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Emission
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Squash
    summary: |
      Allows for non-uniform scaling of particles, curve-controlled over their
      lifetime.
    description: |
      Allows for non-uniform scaling of particles, curve-controlled over their
      lifetime. Values greater than 0 cause particles to both shrink
      horizontally and grow vertically, while values less than 0 cause particles
      to both grow horizontally and shrink vertically.
    code_samples:
    type: NumberSequence
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Appearance
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Texture
    summary: |
      Determines the image rendered on particles.
    description: |
      The **Texture** property determines the image rendered on particles. This
      image is influenced by `Class.ParticleEmitter.Color|Color`,
      `Class.ParticleEmitter.Transparency|Transparency`,
      `Class.ParticleEmitter.LightInfluence|LightInfluence`, and
      `Class.ParticleEmitter.LightEmission|LightEmission`. Textures with
      transparent backgrounds work best for particles.
    code_samples:
    type: Content
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Appearance
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.TimeScale
    summary: |
      Value between 0 and 1 that controls the speed of the particle effect.
    description: |
      A value between 0 and 1 that controls the speed of the particle effect. At
      1, it runs at normal speed; at 0.5 it runs at half speed; at 0 it freezes
      in time.
    code_samples:
    type: float
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Particles
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.Transparency
    summary: |
      Determines the transparency of particles over their individual lifetimes.
    description: |
      The **Transparency** property determines the transparency of all active
      particles over their individual lifetimes. It works similar to
      `Class.ParticleEmitter.Size|Size` in how it affects particles over time.
      In terms of rendering, a value of 0 is completely visible (opaque) and a
      value of 1 is completely invisible (not rendered at all).

      A particle's present transparency is determined by linearly interpolating
      on this sequence using the particle's age and its total lifetime. For
      example, if a particle spawned 2 seconds ago and has a 4 second lifetime,
      the transparency will be whatever is 50% of the way through the
      `Datatype.NumberSequence`. For any `Datatype.NumberSequenceKeypoint` with
      a non-zero envelope value, a random value in the envelope range is chosen
      for each keypoint for each particle when it emits.
    code_samples:
    type: NumberSequence
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Appearance
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.VelocityInheritance
    summary: |
      Determines how much of the parent's velocity is inherited by particles
      when emitted.
    description: |
      The **VelocityInheritance** property determines how much of the parent
      part's `Class.BasePart.Velocity|Velocity` is inherited by particles when
      they are emitted. A value of 0 means that no velocity is inherited, while
      a value of 1 means the particle will have the exact same speed as the
      parent `Class.BasePart`.

      When used in conjunction with `Class.ParticleEmitter.Drag|Drag`, a
      particle emitter can appear to "shed" particles from a moving part.
    code_samples:
    type: float
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Particles
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.VelocitySpread
    summary: |
      Determines how offset a particle can be fired from the local emitter
      direction of its parent.
    description: |
      This property determines how offset a particle can be fired from the local
      emitter direction of its parent. When a particle is created its offset is
      picked randomly between 0 and VelocitySpread. This value is measured in
      degrees.
    code_samples:
    type: float
    tags:
      - NotReplicated
      - Deprecated
    deprecation_message: |
      This property has been superseded by `Class.ParticleEmitter.SpreadAngle`
      which should be used in all new work.
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Emission
    serialization:
      can_load: true
      can_save: false
  - name: ParticleEmitter.WindAffectsDrag
    summary: |
      Whether emitted particles follow the `Class.Workspace.GlobalWind` vector.
    description: |
      If true, emitted particles follow the `Class.Workspace.GlobalWind` vector.
      Only applies if the `Class.ParticleEmitter.Drag|Drag` property is greater
      than 0.
    code_samples: []
    type: bool
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Particles
    serialization:
      can_load: true
      can_save: true
  - name: ParticleEmitter.ZOffset
    summary: |
      Determines the forward-backward render position of particles; used to
      control what particles render on top/bottom.
    description: |
      The **ZOffset** property determines the forward-backward render position
      of particles, in studs, without changing their size on the screen. When
      changed, this property affects both current and future particles. Note
      that this property accepts fractional values; it is not like
      `Class.GuiObject.ZIndex` (an integer).

      Positive values move particles closer to the camera and negative values
      move particles away. Sufficiently negative values can cause particles to
      render inside or behind the parent part.
    code_samples:
    type: float
    tags: []
    deprecation_message: ''
    security:
      read: None
      write: None
    thread_safety: ReadSafe
    category: Appearance
    serialization:
      can_load: true
      can_save: true
methods:
  - name: ParticleEmitter:Clear
    summary: |
      Clears all particles that have been emitted.
    description: |
      The **Clear** method instantly clears all existing particles that have
      been emitted by the `Class.ParticleEmitter` through its natural emission
      (non-zero `Class.ParticleEmitter.Rate|Rate` on an
      `Class.ParticleEmitter.Enabled|Enabled` emitter) or via
      `Class.ParticleEmitter:Emit()|Emit()`.
    code_samples:
      - ParticleEmitter-Burst
    parameters: []
    returns:
      - type: void
        summary: ''
    tags: []
    deprecation_message: ''
    security: None
    thread_safety: Unsafe
  - name: ParticleEmitter:Emit
    summary: |
      Emits a given number of particles.
    description: |
      The **Emit** method will cause the `Class.ParticleEmitter` to instantly
      emit the given number of particles.
    code_samples:
      - Emit-Particles-Over-Distance
      - ParticleEmitter-Burst
    parameters:
      - name: particleCount
        type: int
        default: 16
        summary: |
          The number of particles to emit.
    returns:
      - type: void
        summary: ''
    tags: []
    deprecation_message: ''
    security: None
    thread_safety: Unsafe
events: []
callbacks: []