This rather lengthy code sample shows how every property of a
`ParticleEmitter` can be set, including `Datatype.NumberRange`,
`Datatype.NumberSequence` and `Datatype.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!

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 `Class.BasePart` ou un `Class.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 `Class.ParticleEmitter.Enabled|Enabled` avec un non zéro `Class.ParticleEmitter.Rate|Rate` , ou manuellement lorsque la méthode `Class.ParticleEmitter:Emit()|Emit` est appelée.Avec un non zéro `Class.ParticleEmitter.Speed|Speed` , les particules sont mises en mouvement vers l'extérieur et/ou vers l'intérieur, en fonction de la propriété `Class.ParticleEmitter.ShapeInOut|ShapeInOut`.

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

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

  Pour en savoir plus sur la création et la personnalisation d'émetteurs de particules, voir [émetteurs de particules](/effects/particle-emitters).

This code sample causes a `ParticleEmitter` to `Class.ParticleEmitter:Emit()`
particles in bursts of 10 every 2 seconds. It `Class.ParticleEmitter:Clear()`s
any existing particles before doing so.

La méthode Effacer instantanément efface toutes les particules existantes qui ont été émises par le à travers son émission naturelle (non zéro sur un émetteur) ou via .

ParticleEmitter:Clear

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

This code sample causes a parent `ParticleEmitter` to
`Class.ParticleEmitter:Emit()` particles based on how far the parent
`BasePart` moves.

La méthode **Émettre** fera en sorte que le `Class.ParticleEmitter` émette instantanément le nombre de particules donné.

ParticleEmitter:Emit

particleCount

ParticleEmitter

La propriété **accélération** détermine comment les `Class.ParticleEmitter.Speed|Speed` des particules changent au cours de leur vie.Il est défini en utilisant un `Datatype.Vector3` pour déterminer l'accélération sur les axes globaux **X** / **Y** / **Z** et est mesuré en studs par seconde carrée.Lorsqu'elle est modifiée, cette propriété affecte toutes les particules émises par l'émetteur, à la fois actuelles et futures.

  L'accélération ralentira les particules si les points vectoriels dans l'opposé `Class.ParticleEmitter.EmissionDirection|EmissionDirection` dans lequel elles sont émises. Sinon, elle les accélérera.

ParticleEmitter.Acceleration

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

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

ParticleEmitter.Brightness

La propriété **Couleur** détermine la couleur de toutes les particules actives pendant leur durée de vie individuelle.La couleur s'applique au `Class.ParticleEmitter.Texture|Texture` lors de la rendition et utilise la texture alpha ainsi que l'émetteur de `Class.ParticleEmitter.Transparency|Transparency` .Si un émetteur a une valeur `Class.ParticleEmitter.LightEmission|LightEmission` supérieure à 0, les couleurs plus sombres font apparaître les particules plus transparentes.

  Changer cette propriété affecte toutes les particules émises par l'émetteur, à la fois actuelles et futures.

  Lorsque cette propriété utilise un gradient `Datatype.ColorSequence`, la couleur présente d'une particule est déterminée en interpolant linéairement sur la séquence en utilisant l'âge de la particule et sa durée de vie totale.Par exemple, si une particule est apparue il y a 2 secondes et a une durée de vie de 4 secondes, la couleur sera ce qui est à 50% du chemin à travers le `Datatype.ColorSequence` .

ParticleEmitter.Color

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

La propriété **glisser** détermine le taux en secondes à laquelle les particules individuelles perdront la moitié de leur vitesse par décroissance exponentielle.Glisser est appliqué en augmentant la vitesse attendue à partir de `Class.ParticleEmitter.Speed|Speed` et toute vitesse héritée du parent à partir de `Class.ParticleEmitter.VelocityInheritance|VelocityInheritance`.Définir cette propriété à une valeur négative provoquera une croissance exponentielle de la vitesse des particules.

ParticleEmitter.Drag

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

La propriété **EmissionDirection** détermine le visage ( `Enum.NormalId` ) de l'objet parent à partir duquel les particules émettent.Un négatif `Class.ParticleEmitter.Speed|Speed` signifie que les particules émettent dans la direction opposée.`Class.ParticleEmitter.SpreadAngle|SpreadAngle` plus varie la direction d'émission.

  Si vous ajoutez un `Class.ParticleEmitter` à un `Class.Attachment` qui a une direction, vous pouvez faire pivoter l'attachement lui-même (`Class.Attachment.Orientation`) au lieu d'utiliser cette propriété.

ParticleEmitter.EmissionDirection

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

La propriété **Activée** détermine si les particules émettent de l'émetteur.Définir ceci à `false` arrête la génération de particules supplémentaires, mais toutes les particules existantes restent actives jusqu'à leur expiration.Cette propriété est utile lorsque vous avez un effet de particule préfabriqué que vous voulez laisser désactivé jusqu'à ce que vous en ayez besoin pour émettre des particules.

  Si vous voulez effacer toutes les particules d'un émetteur désactivé, appelez `Class.ParticleEmitter:Clear()|Clear()` .Ensuite, si nécessaire, appelez `Class.ParticleEmitter:Emit()|Emit()` sur l'émetteur pour émettre et rendre des particules.

ParticleEmitter.Enabled

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

La propriété **FlipbookFramerate** détermine la vitesse à laquelle la texture du livre animé se déplace en images par seconde.Comme `Class.ParticleEmitter.Lifetime|Lifetime`, vous pouvez définir une plage minimale et maximale pour randomiser la fréquence de rafraîchissement du livre numérique, avec un maximum de 30 cadres par seconde.

ParticleEmitter.FlipbookFramerate

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

Le message d'erreur à afficher si le `Class.ParticleEmitter.Texture|Texture` n'est pas compatible pour un livre de poche.La texture du livre retourné doit avoir des dimensions de pixels 8×8, 16×16, 32×32, 64×64, 128×128, 256×256, 512×512, ou 1024×1024.

ParticleEmitter.FlipbookIncompatible

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

La propriété **FlipbookLayout** détermine la disposition de la texture. Elle peut être n'importe quelle valeur de l'enumérité `Enum.ParticleFlipbookLayout`

  *   **Aucun** – Désactivez les fonctionnalités de livre numérique et utilisez la texture comme une seule texture statique au cours de la vie de la particule.
  *   **Grille2x2** – 2×2 cadres pour une animationsà 4 cadres.
  *   **Grille4x4** – 4×4 cadres pour une animationsde 16 cadres.
  *   **Grille8x8** – 8×8 cadres pour une animationsde 64 cadres.

ParticleEmitter.FlipbookLayout

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

La propriété **Mode de livre animé** détermine le type de l'animationsde livre animé. Elle peut être n'importe quelle valeur de l'enumérit `Enum.ParticleFlipbookMode`

  *   **Boucle** – Jouer en continu à travers toutes les cadres, en commençant à nouveau par la première cadre après avoir joué la dernière.
  *   **OneShot** – Jouez à travers l'animation une seule fois au cours de la vie de la particule.Avec ce paramètre, la propriété n'est pas appliquée ; à la place, le taux de rafraîchissement est déterminé par la division de la particule par le nombre de cadres dans l'animation. **Les animations OneShot** sont utiles pour des animations non répétitives claires, telles qu'une explosion qui crée un nuage de fumée puis disparaît.
  *   **PingPong** – Jouez de la première à la dernière image, puis en arrière de la dernière à la première, en répétant tout au long du `Class.ParticleEmitter.Lifetime|Lifetime` de la particule.
  *   **Aléatoire** – Jouez les cadres dans un ordre aléatoire, mélangeant/croisant d'un cadre à l'autre.Cela peut être utile pour les textures de particules organiques à des fréquences d'images faibles, telles que les étoiles lentement clignotantes entre des formes subtilement différentes.

ParticleEmitter.FlipbookMode

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

La propriété **FlipbookStartRandom** détermine si chaque particule commence à un cadre aléatoire de l'animation au lieu de toujours commencer par le premier cadre.Un cas d'utilisation est d'activer cette propriété et de définir également `Class.ParticleEmitter.FlipbookFramerate|FlipbookFramerate` à zéro, ce qui fait en sorte que chaque particule émise soit un cadre statique choisi au hasard à partir de la texture du livre numérique.

ParticleEmitter.FlipbookStartRandom

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

La propriété **à vie** définit l'âge maximum et minimum des particules nouvellement émises.Les durées de vie sont stockées sur une base par particule, donc si cette valeur est modifiée, les particules existantes resteront actives jusqu'à la fin de leur durée de vie aléatoire.Une durée de vie de 0 empêchera les particules de s'émettre du tout.

ParticleEmitter.Lifetime

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

La propriété **Émission de lumière** détermine le mélange des couleurs `Class.ParticleEmitter.Texture|Texture` avec les couleurs derrière elles.Une valeur de 0 utilise le mode de mélange normal alors qu'une valeur de 1 utilise le mélange additif.Lorsqu'elle est modifiée, cette propriété affecte instantanément toutes les particules possédées par l'émetteur, à la fois actuelles et futures.

  Cette propriété ne doit pas être confondue avec `Class.ParticleEmitter.LightInfluence|LightInfluence` qui détermine comment les particules sont affectées par la lumière environnementale.

  Cette propriété ne fait pas **pas** que les particules éclairent l'environnement autour d'elles. Pour ce faire, envisagez d'utiliser un `Class.PointLight` .

ParticleEmitter.LightEmission

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

La propriété **influence de la lumière** détermine à quel point la lumière environnementale affecte la couleur des particules individuelles lorsqu'elles rendu.Il doit être dans la plage de 0–1 ; le comportement des valeurs en dehors de cette plage n'est pas défini.À 0, les particules ne sont pas influencées par la lumière du tout (elles conservent la luminosité complète) ; à 1, les particules sont entièrement influencées par la lumière (dans l'obscurité complète, les particules seront noires).

  Par défaut, cette valeur est de 1 si elle est insérée avec des outils de Studio. Si elle est insérée en utilisant `Datatype.Instance.new()`, elle est de 0.

ParticleEmitter.LightInfluence

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

ParticleEmitter.LocalTransparencyModifier

La propriété **Verrouillé à la partie** détermine si les particules "s'accrochent" à la source d'émission (la `Class.Attachment` ou `Class.BasePart` à laquelle le `Class.ParticleEmitter` est parenté).Si `true` , les particules actives se déplaceront en passe de verrouillage si l'objet parent se déplace.

  Alternativement, envisagez d'utiliser la propriété `Class.ParticleEmitter.VelocityInheritance|VelocityInheritance` avec une valeur de 1 qui peut être plus appropriée pour certains effets.

ParticleEmitter.LockedToPart

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

La propriété **Orientation** détermine le mode d'orientation à utiliser pour la géométrie des particules d'un émetteur.

  <table>
    <thead>
      <tr>
        <td>Oriération</td>

        <td>Comportement des particules</td>
      </tr>
    </thead>

    <tbody>
      <tr>
        <td><b>Caméra face à face</b></td>

        <td>Quadruple panneau standard face à la caméra ; comportement par défaut.</td>
      </tr>

      <tr>
        <td><b>Face à la caméra du monde vers le haut</b></td>

        <td>Face à la caméra, mais tournant seulement sur l'axe vertical vers le haut du monde <b>Y</b>.</td>
      </tr>

      <tr>
        <td><b>Vélocité parallèle</b></td>

        <td>Aligné parallèlement à leur direction de mouvement.</td>
      </tr>

      <tr>
        <td><b>Vitesse perpendiculaire</b></td>

        <td>Aligné perpendiculairement à leur mouvement de direction.</td>
      </tr>
    </tbody>
  </table>

ParticleEmitter.Orientation

Spécifie comment orienter les particules.

La propriété **fréquence** détermine le nombre de particules émises par seconde pendant que l'émetteur est `Class.ParticleEmitter.Enabled|Enabled` .C'est l'inverse de la fréquence, ce qui signifie qu'un taux de 5 émet une particule toutes les 0,2 secondes.Lorsqu'elle est modifiée, cette propriété n'a aucun effet sur les particules actives.

ParticleEmitter.Rate

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

La propriété **RotSpeed** détermine une plage aléatoire de vitesses angulaires pour les particules nouvellement émises, mesurée en degrés par seconde.Une vitesse angulaire aléatoire est choisie lors de l'émission, donc le changement de cette propriété n'affecte pas les particules actives.Cette propriété, ainsi que `Class.ParticleEmitter.Rotation|Rotation`, affecte l'angle de l'image de particule rendue.

  Les particules à très grande vitesse angulaire peuvent sembler tourner plus lentement ou pas du tout, puisque l'angle de rotation est synchronisé avec la vitesse de rendu du logiciel.Par exemple, si les particules tournent exactement à 360 degrés à chaque cadre, il n'y aura pas de changement apparent en rotation.

ParticleEmitter.RotSpeed

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

La propriété **Rotation** détermine la portée des rotations en degrés pour les particules nouvellement émises, mesurée en degrés.Les valeurs positives sont dans la direction horaire.Cette propriété est généralement définie à `[0, 360]` pour fournir une rotation complètement aléatoire à de nouvelles particules.`Class.ParticleEmitter.RotSpeed|RotSpeed` influence également la rotation d'une particule au cours de sa vie.

  Les modifications de cette valeur ne concernent que les nouvelles particules ; les particules existantes maintiennent la rotation à laquelle elles ont été émises initialement.

ParticleEmitter.Rotation

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

La propriété **forme** défini la forme de l'émetteur sur une boîte de modélisation, une sphère, un cylindre ou un disque.Après avoir fait une sélection, vous pouvez ajuster les propriétés `Class.ParticleEmitter.ShapeStyle|ShapeStyle`, `Class.ParticleEmitter.ShapeInOut|ShapeInOut` et `Class.ParticleEmitter.ShapePartial|ShapePartial` pour personnaliser encore plus l'émission de particules.Pour des exemples visuels, voir [ici](/effects/particle-emitters#shape) .

ParticleEmitter.Shape

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. Pour des exemples visuels, voir [ici](/effects/particle-emitters#shape).

ParticleEmitter.ShapeInOut

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

En fonction de la valeur `Class.ParticleEmitter.Shape|Shape`, cette propriété effectue une action différente :

  *   Pour les cylindres, il spécifie la proportion du rayon supérieur.Une valeur de 0 signifie que le sommet du cylindre a un rayon de zéro, ce qui le rend un cône.Une valeur de 1 signifie que le cylindre n'a pas de déformation.

  *   Pour les disques, il spécifie la proportion du rayon intérieur.Une valeur de 0 signifie que le disque est entièrement fermé (cercle/ellipse), tandis qu'une valeur de 1 signifie que l'émission ne se produit que sur la jante la plus extérieure du disque.Les valeurs entre 0 et 1 émettent d'un anneau avec une certaine épaisseur.

  *   Pour les sphères, il spécifie l'angle hémisphérique à partir duquel les particules émettent.Une valeur de 1 signifie que des particules émettent de toute la sphère ; une valeur de 0,5 signifie que des particules émettent d'une moitié de dôme ; une valeur de 0 signifie que les particules ne s'émettent que d'un seul point au pôle nord.

  Pour des exemples visuels, voir [ici](/effects/particle-emitters#shape).

ParticleEmitter.ShapePartial

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 à une émission volumétrique ou à une émission exclusive de surface. Pour des exemples visuels, voir [ici](/effects/particle-emitters#shape).

ParticleEmitter.ShapeStyle

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

La propriété **taille** détermine la taille du monde de toutes les particules actives pendant leur durée de vie individuelle.Cette propriété représente les dimensions du carré `Class.ParticleEmitter.Texture|Texture` pour chaque particule.C'est un `Datatype.NumberSequence` qui fonctionne de manière similaire à `Class.ParticleEmitter.Transparency|Transparency` .

  La taille présente d'une particule est déterminée en interpolant linéairement sur cette séquence en utilisant l'âge de la particule et sa durée de vie totale.Par exemple, si une particule est apparue il y a 2 secondes et a une durée de vie de 4 secondes, la taille sera ce qui est à 50% du chemin à travers le `Datatype.NumberSequence`.Pour tout `Datatype.NumberSequenceKeypoint` avec une valeur d'enveloppe non nulle, une valeur aléatoire dans la plage d'enveloppe est choisie pour chaque point clé pour chaque particule lorsqu'elle émet.

ParticleEmitter.Size

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

La propriété **Vitesse** détermine une plage aléatoire de vitesses (du minimum au maximum) à laquelle les nouvelles particules émettront, mesurée en studs par seconde.La vitesse de chaque particule est choisie lors de l'émission et s'applique dans le `Class.ParticleEmitter.EmissionDirection|EmissionDirection` .Les valeurs négatives provoquent le voyage des particules en arrière.

  Notez que le changement de `Class.ParticleEmitter.Speed|Speed` n'affecte pas les particules actives et qu'elles conservent toute la vitesse qu'elles ont déjà.Cependant, `Class.ParticleEmitter.Acceleration|Acceleration` , `Class.ParticleEmitter.Drag|Drag` , et `Class.ParticleEmitter.VelocityInheritance|VelocityInheritance` peuvent être utilisés pour affecter la vitesse des particules actives tout au long de leur vie.

ParticleEmitter.Speed

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

La propriété **Angle de dispersion** détermine les angles aléatoires auxquels une particule peut être émise.Par exemple, si le `Class.ParticleEmitter.EmissionDirection|EmissionDirection` est **Haut** (+ **Y** ), cette `Datatype.Vector2` décrit la taille de la dispersion d'angle aléatoire sur les axes **X** / **Z** , en degrés.

  Définir un axe à 360 degrés provoquera l'émission de particules dans toutes les directions dans un **cercle** .Définir les deux à 360 provoquera l'émission de particules dans toutes les directions dans une **sphère** .

ParticleEmitter.SpreadAngle

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

Permet un dimensionnement non uniforme des particules, contrôlé par courbe tout au long de leur vie.Les valeurs supérieures à 0 font rétrécir les particules horizontalement et grandir verticalement, tandis que les valeurs inférieures à 0 font croître les particules horizontalement et rétrécir verticalement.

ParticleEmitter.Squash

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

La propriété **Texture** détermine l'image rendue sur les particules.Cette image est influencée par `Class.ParticleEmitter.Color|Color` , `Class.ParticleEmitter.Transparency|Transparency` , `Class.ParticleEmitter.LightInfluence|LightInfluence` , et `Class.ParticleEmitter.LightEmission|LightEmission` .Les textures avec arrière-plan transparent fonctionnent mieux pour les particules.

ParticleEmitter.Texture

Détermine l'image rendue sur les particules.

Une valeur entre 0 et 1 qui contrôle la vitesse de l'effet de particule.À 1, il fonctionne à une vitesse normale ; à 0,5, il fonctionne à moitié vitesse ; à 0, il gèle dans le temps.

ParticleEmitter.TimeScale

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

La propriété **Transparence** détermine la transparence de toutes les particules actives au cours de leur durée de vie individuelle.Il fonctionne de manière similaire à `Class.ParticleEmitter.Size|Size` dans la façon dont il affecte les particules au fil du temps.En termes de rendu, une valeur de 0 est complètement visible (opaque) et une valeur de 1 est complètement invisible (pas du tout rendue).

  La transparence présente d'une particule est déterminée en interpolant linéairement sur cette séquence en utilisant l'âge de la particule et sa durée de vie totale.Par exemple, si une particule est apparue il y a 2 secondes et a une durée de vie de 4 secondes, la transparence sera ce qui est à 50% du chemin à travers le `Datatype.NumberSequence`.Pour tout `Datatype.NumberSequenceKeypoint` avec une valeur d'enveloppe non nulle, une valeur aléatoire dans la plage d'enveloppe est choisie pour chaque point clé pour chaque particule lorsqu'elle émet.

ParticleEmitter.Transparency

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

La propriété **héritage de vitesse** détermine à quel point de la partie parent la `Class.BasePart.Velocity|Velocity` est héritée par les particules lorsqu'elles sont émises.Une valeur de 0 signifie qu'aucune vitesse n'est héritée, tandis qu'une valeur de 1 signifie que la particule aura exactement la même vitesse que le parent `Class.BasePart` .

  Lorsqu'il est utilisé en conjonction avec `Class.ParticleEmitter.Drag|Drag`, un émetteur de particules peut sembler « perdre » des particules d'une pièce en mouvement.

ParticleEmitter.VelocityInheritance

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

Cette propriété détermine comment décaler une particule peut être tirée de la direction émettrice locale de son parent.Lorsqu'une particule est créée, son décalage est choisi au hasard entre 0 et VelocitySpread.Cette valeur est mesurée en degrés.

ParticleEmitter.VelocitySpread

Détermine comment décaler une particule peut être tirée de la direction émettrice locale de son parent.

Si c'est vrai, les particules émises suivent le force vectorielle`Class.Workspace.GlobalWind`. S'applique uniquement si la propriété `Class.ParticleEmitter.Drag|Drag` est supérieure à 0.

ParticleEmitter.WindAffectsDrag

Si les particules émises suivent le force vectorielle`Class.Workspace.GlobalWind`.

La propriété **ZOffset** détermine la position de rendu en arrière des particules, en studs, sans modifier leur taille sur l'écran.Lorsqu'elle est modifiée, cette propriété affecte à la fois les particules actuelles et futures.Notez que cette propriété accepte des valeurs fractionnées ; ce n'est pas comme `Class.GuiObject.ZIndex` (un entier).

  Les valeurs positives rapprochent les particules de la caméra et les valeurs négatives éloignent les particules.Des valeurs négatives suffisamment négatives peuvent faire rendre des particules à l'intérieur ou derrière la partie parent.

ParticleEmitter.ZOffset

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.

Un objet spécial qui émet des particules 2D personnalisables dans le monde.

`Instance` est la classe de base pour toutes les classes dans la hiérarchie de classe Roblox qui peuvent faire partie de l'arbre `Class.DataModel`.

  Il n'est pas possible de créer directement des objets racine `Instance` , mais le constructeur spécial `Datatype.Instance.new()` crée des objets via du code, en prenant le nom de la classe en paramètre et en retournant l'objet créé.

Demonstrates detecting changes to an instance's ancestry by connecting to the `Class.Instance.AncestryChanged` event.

The ChangingPart's Parent is set to different values overtime. The parent of the part is the part's ancestor, so the `Class.Instance.AncestryChanged` event will fire whenever it changes.

S'enflamme lorsque la propriété `Class.Instance.Parent` de l'objet ou l'une de ses ancêtres est modifiée.

  Cet événement inclut deux paramètres : `child` se réfère au `Class.Instance` dont le `Class.Instance.Parent` a été effectivement modifié, alors que `parent` se réfère au nouveau `Class.Instance.Parent` de cette instance.

  Vous pouvez utiliser cet événement pour suivre la suppression d'une instance dans Studio, comme la suppression manuelle dans l'Explorateur ou via un plugin.Si vous devez détecter quand une instance est détruite en utilisant `Class.Instance:Destroy()` , utilisez l'événement `Class.Instance.Destroying` à la place.

Instance.AncestryChanged

child

Le `Class.Instance` dont le `Class.Instance.Parent` a été modifié.

parent

Le nouveau `Class.Instance.Parent` de la `Class.Instance` dont le `Class.Instance.Parent` a été modifié.

S'enflamme lorsque la propriété `Class.Instance.Parent` de l'objet ou l'une de ses ancêtres est modifiée.

Cet événement se déclenche chaque fois que n'importe quel attribut est modifié sur l'instance, y compris lorsqu'un attribut est défini sur `nil`.Le nom de l'attribut modifié est transmis à la fonction connectée.

  Par exemple, le fragment de code suivant connecte la fonction `attributeChanged()` à tirer chaque fois que l'un des attributs de la partie change :

  ```lua
  local Workspace = game:GetService("Workspace")

  local part = Workspace.Part

  local function attributeChanged(attributeName)
  	print(attributeName, "changed")
  end

  part.AttributeChanged:Connect(attributeChanged)
  ```

  Voir aussi `Class.Instance:GetAttributeChangedSignal()` qui renvoie un événement qui se déclenche lorsqu'un attribut spécifique change.

Instance.AttributeChanged

attribute

Le nom de l'attribut qui a été modifié.

S'enflamme chaque fois qu'un attribut est modifié sur le `Class.Instance`.

This snippet prints the names of objects as they are added to the Workspace:

Feux après qu'un objet soit parenté à ceci `Class.Instance` .

  Remarque, lors de l'utilisation de cette fonction sur un client pour détecter les objets créés par le serveur, il est nécessaire d'utiliser `Class.Instance:WaitForChild()` lors de l'indexation des descendants de cet objet.C'est parce que l'objet et ses descendants ne sont pas garantis de se répliquer simultanément du serveur au client.Par exemple :

  ```
  local Workspace = game:GetService("Workspace")

  Workspace.ChildAdded:Connect(function(child)
  	-- Use WaitForChild() since descendants may not have replicated yet
  	local head = child:WaitForChild("Head")
  end)
  ```

  Notez que cette fonction ne fonctionne que pour les enfants immédiats du `Class.Instance` . Pour une fonction qui capture tous les descendants, utilisez `Class.Instance.DescendantAdded` .

  Voir aussi `Class.Instance.ChildRemoved` .

Instance.ChildAdded

Feux après qu'un objet soit parenté à ceci `Class.Instance` .

This snippet prints the names of objects as they are removed from the
Workspace:

Feux après qu'un enfant a été retiré de ce `Class.Instance` .

  Supprimé fait référence au moment où le parent d'un objet est modifié de cette `Class.Instance` à quelque chose d'autre que ceci `Class.Instance` .Notez que cet événement se déclenchera également lorsqu'un enfant est détruit (en utilisant `Class.Instance:Destroy()` ) car la fonction destroy définira le parent d'un objet à `nil` .

  Cette fonction ne fonctionne que pour les enfants immédiats du `Class.Instance`. Pour une fonction qui capture tous les descendants, utilisez `Class.Instance.DescendantRemoving`.

  Voir aussi `Class.Instance.ChildAdded` .

Instance.ChildRemoved

Le `Class.Instance` qui a été supprimé.

Feux après qu'un enfant a été retiré de ce `Class.Instance` .

This following example will print the name of any object that is added to the
Workspace:

Cet événement se déclenche après l'ajout d'un descendant à la `Class.Instance`.

  Comme il tire pour chaque descendant, parenter un objet à la `Class.Instance` fera tirer l'événement pour cet objet et tous ses descendants individuellement.

  Si vous ne vous souciez que des enfants directs de la , utilisez à la place.

  Voir aussi `Class.Instance.DescendantRemoving` .

Instance.DescendantAdded

descendant

Feux après qu'un descendant ait été ajouté à la `Class.Instance`.

The following example prints the name of any descendant as it is being removed
from the Workspace:

Cet événement se déclenche **immédiatement avant** que le parent `Class.Instance` de telle sorte qu'une instance **descendante** ne sera plus une descendante.`Class.Instance:Destroy()|Destroy()` change le `Class.Instance.Parent|Parent` d'une instance en `nil`, donc l'appel de cette méthode sur un descendant du parent provoquera le déclenchement de cet événement.

  Puisque cet événement se déclenche avant **la suppression du descendant, le parent du descendant sera inchangé au moment du déclenchement de cet événement** .Si le descendant est également un enfant direct du parent, cet événement se déclenchera avant .

  Si un descendant a des enfants, cet événement se déclenche d'abord avec le descendant, suivi de ses descendants.

  ##### Avertissement

  Cet événement se déclenche avec l'objet descendant qui est supprimé.Tenter de définir le `Class.Instance.Parent|Parent` du descendant sur autre chose échouera.Ci-dessous est un exemple qui montre cela :

  ```
  local Workspace = game:GetService("Workspace")

  Workspace.DescendantRemoving:Connect(function(descendant)
  	-- Do not manipulate the parent of the descendant in this function!
  	-- This event fires BECAUSE the parent was manipulated, and the change hasn't happened yet
  	-- Therefore, it is problematic to change the parent like this:
  	descendant.Parent = game
  end)

  local part = Instance.new("Part")
  part.Parent = Workspace
  part.Parent = nil
  ```

  Voir aussi `Class.Instance.DescendantAdded|DescendantAdded` .

Instance.DescendantRemoving

Le `Class.Instance` qui est en train d'être supprimé.

S'enflamme immédiatement avant que le descendant du `Class.Instance` soit supprimé.

This sample demonstrates how, when using Immediate signal behavior, an Instance being destroyed remains in place until the connected function yields.

This sample demonstrates how, when using Deferred signal behavior,
an Instance is destroyed before the signal fires.

La `Class.Instance` ne sera jamais supprimée de la mémoire tant qu'une fonction connectée l'utilise encore.Cependant, si la fonction produit à tout moment, le `Class.Instance` et ses descendants seront parentés à `nil` .

  Si la propriété `Class.Workspace.SignalBehavior` est définie sur `Enum.SignalBehavior.Immediate`, cet événement se déclenche immédiatement avant que `Class.Instance` ou l'un de ses ancêtres ne soit détruit avec `Class.Instance:Destroy()` .

  Si la propriété `Class.Workspace.SignalBehavior` est définie sur `Enum.SignalBehavior.Deferred`, cet événement se déclenche au prochain point de reprise, qui sera après que le `Class.Instance` ou l'un de ses ancêtres a été détruit avec `Class.Instance:Destroy()` .

  Avec le comportement `Enum.SignalBehavior.Deferred|Deferred`, la connexion d'un script à son propre événement `Class.Instance.Destroying` est problématique, car le script sera détruit avant que le rappel puisse être appelé (ce qui signifie qu'il ne sera pas exécuté).

  Lors de la suppression d'un `Class.Instance` dans Studio, comme la suppression manuelle via le [Explorateur](/studio/explorer) ou via un plugin, le `Class.Instance` n'est pas détruit.Au lieu de cela, le parent est défini sur `nil` que vous pouvez suivre avec `Class.Instance.AncestryChanged` .

Instance.Destroying

Il se déclenche immédiatement avant (ou est reporté jusqu'à ce que) l'instance soit détruite via `Class.Instance:Destroy()` .

Cet événement se déclenche chaque fois que toute propriété de style est modifiée sur l'instance, y compris lorsque une propriété est définie sur `nil` .

  ```lua
  local Players = game:GetService("Players")

  local player = Players.LocalPlayer
  local playerGui = player.PlayerGui
  local HUDContainer = playerGui:WaitForChild("HUDContainer")
  local meterBar = HUDContainer.MeterBar

  local function stylePropertyChanged()
  	print("Styled properties changed")
  end

  meterBar:StyledPropertiesChanged():Connect(stylePropertyChanged)
  ```

Instance.StyledPropertiesChanged

Il se déclenche chaque fois que toute propriété de style est modifiée sur l'instance, y compris lorsqu'une propriété est définie sur `nil` .

Instance.childAdded

Cette méthode applique une balise à l'instance, sans effet si la balise est déjà appliquée.Ajouter avec succès une balise déclenchera un signal créé par `Class.CollectionService:GetInstanceAddedSignal()` avec la balise donnée.

  ##### Avertissements

  *   Les balises d'une instance qui ont été ajoutées côté client seront supprimées si le serveur ajoute ou supprime plus tard une balise sur cette instance car le serveur réplique toutes les balises ensemble et remplace les balises précédentes.

  *   Lors du marquage d'une instance, il est courant que certaines ressources soient utilisées pour donner au tag sa fonctionnalité, par exemple des connexions d'événements ou des tables.Pour empêcher les fuites de mémoire, il est une bonne idée de les nettoyer (débrancher, réinitialiser à `nil` , etc.) lorsqu'elles ne sont plus nécessaires pour une balise.Faites ceci lorsque vous appelez `Class.Instance:RemoveTag()`, appelez `Class.Instance:Destroy()` ou dans une fonction connectée à un signal retourné par `Class.CollectionService:GetInstanceRemovedSignal()` .

Instance:AddTag

Cette fonction détruit tous les enfants et les descendants d'une instance.

  ```
  local part = Instance.new("Part")

  -- Add some sparkles
  for i = 1, 3 do
  	local sparkles = Instance.new("Sparkles")
  	sparkles.Parent = part

    local sc = Instance.new("Sparkles")
    sc.Parent = sparkles
  end

  print("Children:", #part:GetChildren())  --> Children: 3

  part:ClearAllChildren()

  print("Children:", #part:GetChildren())  --> Children: 0
  ```

  Si vous ne souhaitez pas détruire **tous** les enfants et les descendants, utilisez `Class.Instance:GetChildren()` ou `Class.Instance:GetDescendants()` pour parcourir ces enfants/descendants et sélectionnez ce que vous devez détruire.Par exemple, l'exemple de code suivant détruira tous les `Class.BasePart|BaseParts` descendant d'un `Class.Model` :

  ```
  local Workspace = game:GetService("Workspace")

  local model = Workspace:FindFirstChild("TestModel")

  for _, descendant in model:GetDescendants() do
  	if descendant:IsA("BasePart") then
  		descendant:Destroy()
  	end
  end
  ```

Instance:ClearAllChildren

Cette fonction détruit tous les enfants d'une instance.

Demonstrates cloning a model using `Class.Instance:Clone()`.

`Clone()` crée une copie d'une instance et de tous ses descendants, en ignorant toutes les instances qui ne sont pas `Class.Instance.Archivable|Archivable` .Une copie de l'instance racine est retournée par cette méthode et son `Class.Instance.Parent|Parent` est défini sur `nil` .Notez que si l'instance elle-même a `Class.Instance.Archivable|Archivable` définie à `false`, cette fonction retournera `nil` .

  Si une propriété de référence telle que `Class.ObjectValue.Value` est définie dans une instance clonée, la valeur de la propriété de la copie dépend de la valeur de l'original :

  *   Si une propriété de référence se réfère à une instance qui a été **également** clonée, la copie se référera à la copie.
  *   Si une propriété de référence se réfère à un objet qui n'a pas été **cloné** , la même valeur est maintenue dans la copie.

Instance:Clone

Créer une copie d'une instance et de tous ses descendants, en ignorant les instances qui ne sont pas `Class.Instance.Archivable|Archivable` .

Demonstrates destroying a Part using the `Class.Instance:Destroy()` function.

This function is the correct way to dispose of objects that are no longer required.

Définit la propriété `Class.Instance.Parent` à `nil`, verrouille la propriété `Class.Instance.Parent` et déconnecte toutes les connexions, puis appelle `Destroy()` sur tous les enfants.Cette fonction est la bonne façon de se débarrasser d'objets qui ne sont plus nécessaires.

  L'élimination des objets inutiles est importante, car les objets inutiles et les connexions dans un endroit utilisent la mémoire qui peut entraîner des problèmes de performance sérieux au fil du temps.

  En tant que meilleure pratique après avoir appelé `Destroy()` sur un objet, définissez toutes les variables qui font référence à l'objet (ou à ses descendants) à `nil` .Cela empêche votre code d'accéder à quoi que ce soit ayant à voir avec l'objet.

  ```lua
  local part = Instance.new("Part")
  part.Name = "Hello, world"
  part:Destroy()
  -- Ne faites pas cela :
  print(part.Name)  --> "Bonjour, monde"
  -- Faites ceci pour empêcher la ligne ci-dessus de fonctionner :
  part = nil
  ```

  Une fois qu'une `Class.Instance` a été détruite par cette méthode, elle ne peut pas être réutilisée car la propriété `Class.Instance.Parent` est verrouillée.Pour **temporairement** supprimer un objet au lieu de le détruire, définissez `Class.Instance.Parent|Parent` à `nil` .Par exemple :

  ```
  local Workspace = game:GetService("Workspace")

  object.Parent = nil
  task.wait(2)
  object.Parent = Workspace
  ```

  Pour détruire un objet après un certain nombre de temps, utilisez `Class.Debris:AddItem()` .

Instance:Destroy

Définit la propriété `Class.Instance.Parent` à `nil`, verrouille la propriété `Class.Instance.Parent` et déconnecte toutes les connexions, puis appelle `Destroy()` sur tous les enfants.

Renvoie le premier ancêtre du `Class.Instance` dont le `Class.Instance.Name` est égal au nom donné.

  Cette fonction fonctionne en aval, ce qui signifie qu'elle commence à l'instant immédiat de l'instance `Class.Instance.Parent` et fonctionne vers le `Class.DataModel`.Si aucun ancêtre correspondant n'est trouvé, il renvoie `nil` .

  Le fragment de code suivant trouverait le premier ancêtre de l'objet nommé `Car` .

  ```
  local car = object:FindFirstAncestor("Car")
  ```

  Pour les variantes de cette fonction qui trouvent des ancêtres d'une classe spécifique, voir `Class.Instance:FindFirstAncestorOfClass()` et `Class.Instance:FindFirstAncestorWhichIsA()` .

Instance:FindFirstAncestor

name

Renvoie le premier ancêtre du `Class.Instance` dont le `Class.Instance.Name` est égal au nom donné.

Renvoie le premier ancêtre du `Class.Instance` dont le `Class.Object.ClassName` est égal à la classe donnée.

  Cette fonction fonctionne en aval, ce qui signifie qu'elle commence à l'instant immédiat de l'instance `Class.Instance.Parent` et fonctionne vers le `Class.DataModel`.Si aucun ancêtre correspondant n'est trouvé, il renvoie `nil` .

  Un usage commun de cette fonction est de trouver le appartient à. Par exemple :

  ```
  local model = part:FindFirstAncestorOfClass("Model")
  ```

  Cette fonction est une variante de `Class.Instance:FindFirstAncestor()` qui vérifie la propriété `Class.Object.ClassName` plutôt que `Class.Instance.Name`.`Class.Instance:FindFirstAncestorWhichIsA()` existe également, en utilisant la méthode `Class.Object:IsA()` au lieu de respecter l'héritage de classe.

Instance:FindFirstAncestorOfClass

className

Le `Class.Object.ClassName` à rechercher.

Renvoie le premier ancêtre du `Class.Instance` dont le `Class.Object.ClassName` est égal à la classe donnée.

Retourne le premier ancêtre du `Class.Instance` pour lequel `Class.Object:IsA()` renvoie vrai pour la classe donnée.

  Cette fonction fonctionne en aval, ce qui signifie qu'elle commence à l'instant immédiat de l'instance `Class.Instance.Parent` et fonctionne vers le `Class.DataModel`.Si aucun ancêtre correspondant n'est trouvé, il renvoie `nil` .

  Contrairement à `Class.Instance:FindFirstAncestorOfClass()`, cette fonction utilise `Class.Object:IsA()` qui respecte l'héritage de classe. Par exemple :

  ```
  print(part:IsA("Part"))  --> true
  print(part:IsA("BasePart"))  --> true
  print(part:IsA("Instance"))  --> true
  ```

  La suite du code suivante retournera donc le premier ancêtre , ou , indépendamment du fait qu'il s'agisse d'un , ou .

  ```
  local part = object:FindFirstAncestorWhichIsA("BasePart")
  ```

  Voir aussi `Class.Instance:FindFirstAncestor()` .

Instance:FindFirstAncestorWhichIsA

Retourne le premier ancêtre du `Class.Instance` pour lequel `Class.Object:IsA()` renvoie vrai pour la classe donnée.

Ce qui suit rechercherait dans l'espace de travail un nom d'objet « Brick ». S'il est trouvé, il changerait le nom de l'objet en « Foo ».

Retourne le premier enfant du `Class.Instance` avec le nom donné, ou `nil` si aucun tel enfant n'existe.Si l'argument facultatif `recursive` optionnel est `true`, cette fonction recherche tous les descendants plutôt que les enfants immédiats du `Class.Instance`.

  ##### Vérification de l'existence d'un objet

  `FindFirstChild()` est nécessaire si vous devez vérifier qu'un objet existe avant de continuer.Tenter d'indexer un enfant par son nom en utilisant l'opérateur point provoque une erreur si l'enfant n'existe pas.

  ```lua
  local Workspace = game:GetService("Workspace")

  -- Les erreurs suivantes se produisent si la partie n'existe pas dans l'espace de travail
  Workspace.Part.Transparency = 0.5
  ```

  Une meilleure approche consiste à utiliser `FindFirstChild()` pour vérifier d'abord `Part` , puis à utiliser une déclaration `if` pour exécuter du code qui en a besoin.

  ```lua
  local Workspace = game:GetService("Workspace")

  local part = Workspace:FindFirstChild("Part")
  if part then
  	part.Transparency = 0.5
  end
  ```

  ##### Trouver un enfant dont le nom correspond à une propriété

  Parfois, le `Class.Instance.Name|Name` d'un objet est le même que celui d'une propriété de son `Class.Instance.Parent|Parent` .Lors de l'utilisation de l'opérateur point, les propriétés prennent le pas sur les enfants s'ils partagent un nom.

  Dans l'exemple suivant, un `Class.Folder` appelé `Color` est ajouté à un `Class.Part` qui a également la propriété `Class.Part.Color`.Remarquez que `part.Color` se réfère à la valeur de propriété `Datatype.Color3`, pas à l'instance enfant `Class.Folder`.Un avantage de l'utilisation de `Class.Instance:FindFirstChild()|FindFirstChild()` est que l'introduction de nouvelles propriétés n'impose pas de risque pour votre code.

  ```lua
  local part = Instance.new("Part")
  local folder = Instance.new("Folder")
  folder.Name = "Color"
  folder.Parent = part
  local c1 = part.Color  -- La propriété
  local c2 = part:FindFirstChild("Color")  -- The child folder
  ```

  ##### Notes de performances

  `Class.Instance:FindFirstChild()|FindFirstChild()` prend environ 20 % plus de temps que l'utilisation de l'opérateur point et presque 8 fois plus de temps que simplement le stockage d'une référence à un objet.Vous devez donc éviter de l'appeler dans du code dépendant de la performance, comme dans des boucles serrées ou des fonctions connectées à `Class.RunService.Heartbeat` et `Class.RunService.PreRender` .Au lieu de cela, stockez le résultat dans une variable, ou envisagez d'utiliser `Class.Instance.ChildAdded|ChildAdded` ou `Class.Instance:WaitForChild()|WaitForChild()` pour détecter quand un enfant d'un nom donné devient disponible.

Instance:FindFirstChild

recursive

Si la recherche doit être menée de manière récursive ou non.

Renvoie le premier enfant du `Class.Instance` trouvé avec le nom donné.

Retourne le premier enfant du `Class.Instance` dont le `Class.Object.ClassName|ClassName` est égal au donné `className` .Contrairement à `Class.Instance:FindFirstChildWhichIsA()` , cette fonction ne renvoie que des objets dont la classe correspond à `className` , en ignorant l'héritage de classe.Si aucun enfant correspondant n'est trouvé, cette fonction renvoie `nil` .

Instance:FindFirstChildOfClass

Retourne le premier enfant du `Class.Instance` dont le `Class.Object.ClassName|ClassName` est égal au nom de classe donné.

Retourne le premier enfant du `Class.Instance` pour lequel `Class.Object:IsA()` renvoie vrai pour la classe donnée.

  Si aucun enfant correspondant n'est trouvé, cette fonction renvoie `nil` .Si l'argument récursif facultatif est vrai, cette fonction recherche tous les descendants plutôt que les enfants immédiats de la `Class.Instance` .

  Contrairement à `Class.Instance:FindFirstChildOfClass()`, cette fonction utilise `Class.Object:IsA()` qui respecte l'héritage de classe. Par exemple :

  ```lua
  print(part:IsA("Part")) --> vrai
  print(part:IsA("BasePart")) --> vrai
  print(part:IsA("Instance")) --> true
  ```

  Par conséquent, l'exemple de code suivant retournera le premier enfant `Class.BasePart` , indépendamment du fait qu'il s'agisse d'un `Class.WedgePart` , `Class.MeshPart` ou `Class.Part` .

  ```
  local part = object:FindFirstChildWhichIsA("BasePart")
  ```

  Les développeurs qui recherchent un enfant par nom devraient utiliser `Class.Instance:FindFirstChild()` à la place.

Instance:FindFirstChildWhichIsA

Retourne le premier enfant du `Class.Instance` pour lequel `Class.Object:IsA()` renvoie vrai pour la classe donnée.

Renvoie le premier descendant trouvé avec le donné `Class.Instance.Name` .

  Cette méthode est désactivée et ne peut pas être utilisée.Pour trouver le premier descendant d'une instance, envisagez d'utiliser le paramètre `recursive` sur `Class.Instance:FindFirstChild()` à la place.

Instance:FindFirstDescendant

Renvoie le premier descendant trouvé avec le donné `Class.Instance.Name` .

Si le `Class.Instance` est un `Class.Actor`, le `Class.Actor` lui-même est renvoyé.Sinon, son ancêtre le plus proche `Class.Actor` est retourné.Si aucun ancêtre n'est un `Class.Actor` , le résultat est `nil` .

Instance:GetActor

Retourne le `Class.Actor` associé à l'instance, si nécessaire.

Cette méthode renvoie la valeur qui a été attribuée au nom d'attribut donné. Si aucun attribut n'a été attribué, `nil` est renvoyé.

  Par exemple, le fragment de code suivant définit puis obtient la valeur de l'attribut `InitialPosition` de l'instance :

  ```lua
  local Workspace = game:GetService("Workspace")

  local part = Workspace.Part
  part:SetAttribute("InitialPosition", part.Position)

  local initialPosition = instance:GetAttribute("InitialPosition")
  print(initialPosition)
  ```

  ##### Voir aussi

  *   `Class.Instance:SetAttribute()` qui définit l'attribut avec le nom donné à la valeur donnée.
  *   `Class.Instance:GetAttributes()` qui renvoie un dictionnaire de paires clé-valeur pour chacun des attributs de l'instance.

Instance:GetAttribute

Renvoie la valeur qui a été attribuée au nom d'attribut donné.

Instance

`Instance` est la classe de base pour toutes les classes dans la hiérarchie de classe Roblox qui peuvent faire partie de l'arbre `Class.DataModel`.

/reference/engine/classes/ParticleEmitter.yaml