ParticleEmitter

Afficher les obsolètes

*Ce contenu est traduit en utilisant l'IA (Beta) et peut contenir des erreurs. Pour consulter cette page en anglais, clique ici.

Un émetteur de particules est un objet spécial qui émet des particules 2D personnalisables dans le monde.Pour émettre et rendre des particules, il doit être parenté à un BasePart ou un Attachment à l'intérieur d'une telle partie.Lorsqu'il est parenté à un , les particules apparaissent de manière aléatoire dans la boîte de bordure ou la forme de la partie ou ; lorsqu'il est parenté à un , les particules apparaissent à partir de la position de l'point d'attache.

Les particules s'émettent automatiquement lorsque l'émetteur est Enabled avec un non zéro Rate , ou manuellement lorsque la méthode Emit est appelée.Avec un non zéro Speed , les particules sont mises en mouvement vers l'extérieur et/ou vers l'intérieur, en fonction de la propriété ShapeInOut.

Par défaut, les particules font face à la caméra, mais le Orientation peut être modifié pour respecter la vitesse des particules à la place.

Pendant le Lifetime des particules, elles peuvent changer d'apparence selon le Color et le Size.Leur motion peut changer au fil du temps selon les propriétés Drag et Acceleration, et ils peuvent également se déplacer lorsque leur parent se déplace lorsqu'ils sont LockedToPart ou ont une propriété non nulle VelocityInheritance.

Pour en savoir plus sur la création et la personnalisation d'émetteurs de particules, voir émetteurs de particules.

Échantillons de code

This rather lengthy code sample shows how every property of a ParticleEmitter can be set, including NumberRange, NumberSequence and ColorSequence properties. Below is how the ParticleEmitter should look after every property is set. Try playing around with the different properties to customize how the effect looks!

Creating a Particle Emitter from Scratch

local emitter = Instance.new("ParticleEmitter")
-- Number of particles = Rate * Lifetime
emitter.Rate = 5 -- Particles per second
emitter.Lifetime = NumberRange.new(1, 1) -- How long the particles should be alive (min, max)
emitter.Enabled = true
-- Visual properties
emitter.Texture = "rbxassetid://1266170131" -- A transparent image of a white ring
-- For Color, build a ColorSequence using ColorSequenceKeypoint
local colorKeypoints = {
-- API: ColorSequenceKeypoint.new(time, color)
ColorSequenceKeypoint.new(0, Color3.new(1, 1, 1)), -- At t=0, White
ColorSequenceKeypoint.new(0.5, Color3.new(1, 0.5, 0)), -- At t=.5, Orange
ColorSequenceKeypoint.new(1, Color3.new(1, 0, 0)), -- At t=1, Red
}
emitter.Color = ColorSequence.new(colorKeypoints)
local numberKeypoints = {
-- API: NumberSequenceKeypoint.new(time, size, envelop)
NumberSequenceKeypoint.new(0, 1), -- At t=0, fully transparent
NumberSequenceKeypoint.new(0.1, 0), -- At t=.1, fully opaque
NumberSequenceKeypoint.new(0.5, 0.25), -- At t=.5, mostly opaque
NumberSequenceKeypoint.new(1, 1), -- At t=1, fully transparent
}
emitter.Transparency = NumberSequence.new(numberKeypoints)
emitter.LightEmission = 1 -- When particles overlap, multiply their color to be brighter
emitter.LightInfluence = 0 -- Don't be affected by world lighting
-- Speed properties
emitter.EmissionDirection = Enum.NormalId.Front -- Emit forwards
emitter.Speed = NumberRange.new(0, 0) -- Speed of zero
emitter.Drag = 0 -- Apply no drag to particle motion
emitter.VelocitySpread = NumberRange.new(0, 0)
emitter.VelocityInheritance = 0 -- Don't inherit parent velocity
emitter.Acceleration = Vector3.new(0, 0, 0)
emitter.LockedToPart = false -- Don't lock the particles to the parent
emitter.SpreadAngle = Vector2.new(0, 0) -- No spread angle on either axis
-- Simulation properties
local numberKeypoints2 = {
NumberSequenceKeypoint.new(0, 0), -- At t=0, size of 0
NumberSequenceKeypoint.new(1, 10), -- At t=1, size of 10
}
emitter.Size = NumberSequence.new(numberKeypoints2)
emitter.ZOffset = -1 -- Render slightly behind the actual position
emitter.Rotation = NumberRange.new(0, 360) -- Start at random rotation
emitter.RotSpeed = NumberRange.new(0) -- Do not rotate during simulation
-- Create an attachment so particles emit from the exact same spot (concentric rings)
local attachment = Instance.new("Attachment")
attachment.Position = Vector3.new(0, 5, 0) -- Move the attachment upwards a little
attachment.Parent = script.Parent
emitter.Parent = attachment

Résumé

Propriétés

  • Lecture parallèle

    Détermine l'accélération de l'axe global de tous les particules actives, mesurée en studs par seconde carrée.

  • Lecture parallèle

    Échelle la lumière émise par l'émetteur lorsque ParticleEmitter.LightInfluence est 0.

  • Lecture parallèle

    Détermine la couleur de toutes les particules actives pendant leur durée de vie individuelle.

  • Lecture parallèle

    Détermine le taux auquel les particules perdront la moitié de leur vitesse par décroissance exponentielle.

  • Détermine le visage de l'objet d'où les particules émettent.

  • Lecture parallèle

    Détermine si les particules émettent de l'émetteur.

  • Lecture parallèle

    Détermine la vitesse à laquelle la texture du livre animé se déplace en images par seconde.

  • Lecture parallèle

    Le message d'erreur à afficher si le Texture n'est pas compatible pour un livre de poche.

  • Détermine la structure de la texture du livre à retourner. Doit être aucune, grille2x2, grille4x4 ou grille8x8.

  • Détermine le type d'animationsde livre numérique. Doit être Loop, OneShot, PingPong ou Random.

  • Lecture parallèle

    Détermine si l'animation commence à un cadre aléatoire choisi par particule au lieu de toujours commencer à zéro cadre.

  • Lecture parallèle

    Définit une plage aléatoire d'âges pour les particules nouvellement émises.

  • Lecture parallèle

    Détermine la quantité de couleurs des particules qui se mélangent avec les couleurs derrière elles.

  • Lecture parallèle

    Détermine la quantité de particules influencées par la lumière environnementale.

  • Caché
    Non répliqué
    Lecture parallèle
  • Lecture parallèle

    Détermine si les particules se déplacent rigoureusement avec la pièce d'où elles sont émises.

  • Spécifie comment orienter les particules.

  • Lecture parallèle

    Détermine le nombre de particules émises par seconde.

  • Lecture parallèle

    Détermine la plage de vitesses angulaires des particules émises, mesurée en degrés par seconde.

  • Lecture parallèle

    Détermine la plage de rotations en degrés pour les particules nouvellement émises.

  • Définit la forme de l'émetteur à une boîte de modélisation, une sphère, un cylindre ou un disque.

  • Définit si les particules émettent vers l'extérieur uniquement, vers l'intérieur uniquement, ou dans les deux directions.

  • Lecture parallèle

    Influence l'émission de particules du cylindre, du disque, de la sphère et de la forme de boîte.

  • Définit l'émission de particules à l'émission volumétrique ou à l'émission exclusive de surface.

  • Lecture parallèle

    Détermine la taille du monde au cours de la vie des particules individuelles.

  • Lecture parallèle

    Détermine une plage aléatoire de vitesses (minimum à maximum) à laquelle les nouvelles particules émettront, mesurée en studs par seconde.

  • Lecture parallèle

    Détermine les angles auxquels les particules peuvent être émises aléatoirement, mesurés en degrés.

  • Lecture parallèle

    Permet un dimensionnement non uniforme des particules, contrôlé par courbe tout au long de leur vie.

  • Texture:ContentId
    Lecture parallèle

    Détermine l'image rendue sur les particules.

  • Lecture parallèle

    Valeur comprise entre 0 et 1 qui contrôle la vitesse de l'effet de particule.

  • Lecture parallèle

    Détermine la transparence des particules au cours de leurs vies individuelles.

  • Lecture parallèle

    Détermine la quantité de la vitesse du parent qui est héritée par les particules lorsqu'elles sont émises.

  • Lecture parallèle

    Si les particules émises suivent le force vectorielleWorkspace.GlobalWind.

  • Lecture parallèle

    Détermine la position de rendu en avant en arrière des particules ; utilisée pour contrôler ce que les particules rendent en haut/en bas.

Méthodes

  • Clear():()

    Supprime toutes les particules qui ont été émises.

  • Emit(particleCount : number):()

    Émet un nombre donné de particules.

Propriétés

Acceleration

Lecture parallèle

Brightness

Lecture parallèle
Lecture parallèle

Drag

Lecture parallèle

EmissionDirection

Lecture parallèle

Enabled

Lecture parallèle

FlipbookFramerate

Lecture parallèle

FlipbookIncompatible

Lecture parallèle
Lecture parallèle
Lecture parallèle

FlipbookStartRandom

Lecture parallèle

Lifetime

Lecture parallèle

LightEmission

Lecture parallèle

LightInfluence

Lecture parallèle

LocalTransparencyModifier

Caché
Non répliqué
Lecture parallèle

LockedToPart

Lecture parallèle
Lecture parallèle

Rate

Lecture parallèle

RotSpeed

Lecture parallèle

Rotation

Lecture parallèle
Lecture parallèle
Lecture parallèle

ShapePartial

Lecture parallèle
Lecture parallèle
Lecture parallèle
Lecture parallèle

SpreadAngle

Lecture parallèle
Lecture parallèle

Texture

ContentId
Lecture parallèle

TimeScale

Lecture parallèle

Transparency

Lecture parallèle

VelocityInheritance

Lecture parallèle

WindAffectsDrag

Lecture parallèle

ZOffset

Lecture parallèle

Méthodes

Clear

()

Retours

()

Échantillons de code

ParticleEmitter Burst

local emitter = script.Parent
while true do
emitter:Clear()
emitter:Emit(10)
task.wait(2)
end

Emit

()

Paramètres

particleCount: number
Valeur par défaut : 16

Retours

()

Échantillons de code

Emit Particles Over Distance

local RunService = game:GetService("RunService")
local emitter = script.Parent
local part = emitter.Parent
local PARTICLES_PER_STUD = 3
local lastPosition = part.Position
local distance = 0
local function onStep()
local displacement = part.Position - lastPosition
distance = distance + displacement.magnitude
local n = math.floor(distance * PARTICLES_PER_STUD)
emitter:Emit(n)
distance = distance - n / PARTICLES_PER_STUD
lastPosition = part.Position
end
RunService.Stepped:Connect(onStep)
emitter.Enabled = false
ParticleEmitter Burst

local emitter = script.Parent
while true do
emitter:Clear()
emitter:Emit(10)
task.wait(2)
end

Événements