Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

CPUParticles2D

Hérite de : Node2D < CanvasItem < Node < Object

Un émetteur de particules 2D basé sur le CPU.

Description

Nœud de particules 2D calculées par le CPU pour créer une variété de systèmes et d'effets de particules.

Voir aussi GPUParticles2D, qui fournit la même fonctionnalité en utilisant l'accélération matérielle, mais peut ne pas fonctionner sur des appareils plus anciens.

Tutoriels

Propriétés

int

amount

8

Curve

angle_curve

float

angle_max

0.0

float

angle_min

0.0

Curve

angular_velocity_curve

float

angular_velocity_max

0.0

float

angular_velocity_min

0.0

Curve

anim_offset_curve

float

anim_offset_max

0.0

float

anim_offset_min

0.0

Curve

anim_speed_curve

float

anim_speed_max

0.0

float

anim_speed_min

0.0

Color

color

Color(1, 1, 1, 1)

Gradient

color_initial_ramp

Gradient

color_ramp

Curve

damping_curve

float

damping_max

0.0

float

damping_min

0.0

Vector2

direction

Vector2(1, 0)

DrawOrder

draw_order

0

PackedColorArray

emission_colors

PackedVector2Array

emission_normals

PackedVector2Array

emission_points

Vector2

emission_rect_extents

float

emission_ring_inner_radius

float

emission_ring_radius

EmissionShape

emission_shape

0

float

emission_sphere_radius

bool

emitting

true

float

explosiveness

0.0

int

fixed_fps

0

bool

fract_delta

true

Vector2

gravity

Vector2(0, 980)

Curve

hue_variation_curve

float

hue_variation_max

0.0

float

hue_variation_min

0.0

float

initial_velocity_max

0.0

float

initial_velocity_min

0.0

float

lifetime

1.0

float

lifetime_randomness

0.0

Curve

linear_accel_curve

float

linear_accel_max

0.0

float

linear_accel_min

0.0

bool

local_coords

false

bool

one_shot

false

Curve

orbit_velocity_curve

float

orbit_velocity_max

0.0

float

orbit_velocity_min

0.0

bool

particle_flag_align_y

false

PhysicsInterpolationMode

physics_interpolation_mode

2 (overrides Node)

float

preprocess

0.0

Curve

radial_accel_curve

float

radial_accel_max

0.0

float

radial_accel_min

0.0

float

randomness

0.0

Curve

scale_amount_curve

float

scale_amount_max

1.0

float

scale_amount_min

1.0

Curve

scale_curve_x

Curve

scale_curve_y

int

seed

0

float

speed_scale

1.0

bool

split_scale

false

float

spread

45.0

Curve

tangential_accel_curve

float

tangential_accel_max

0.0

float

tangential_accel_min

0.0

Texture2D

texture

bool

use_fixed_seed

false

Méthodes

void

convert_from_particles(particles: Node)

Curve

get_param_curve(param: Parameter) const

float

get_param_max(param: Parameter) const

float

get_param_min(param: Parameter) const

bool

get_particle_flag(particle_flag: ParticleFlags) const

void

request_particles_process(process_time: float, process_time_residual: float = 0.0)

void

restart(keep_seed: bool = false)

void

set_param_curve(param: Parameter, curve: Curve)

void

set_param_max(param: Parameter, value: float)

void

set_param_min(param: Parameter, value: float)

void

set_particle_flag(particle_flag: ParticleFlags, enable: bool)

Signaux

finished() 🔗

Émis lorsque toutes les particules actives ont terminé le traitement. Lorsque one_shot est désactivé, les particules traiteront continuellement, il ne sera donc jamais émis.

Énumérations

enum DrawOrder: 🔗

DrawOrder DRAW_ORDER_INDEX = 0

Les particules sont affichées dans l'ordre dans lequel elles ont été émises.

DrawOrder DRAW_ORDER_LIFETIME = 1

Les particules sont dessinées dans l'ordre de leur durée de vie restante. En d'autres termes, la particule avec la durée de vie la plus grande est dessinée à l'avant.

enum Parameter: 🔗

Parameter PARAM_INITIAL_LINEAR_VELOCITY = 0

À utiliser avec set_param_min(), set_param_max(), et set_param_curve() pour définir les propriétés de vélocité initiale.

Parameter PARAM_ANGULAR_VELOCITY = 1

À utiliser avec set_param_min(), set_param_max(), et set_param_curve() pour définir les propriétés de vitesse angulaire.

Parameter PARAM_ORBIT_VELOCITY = 2

À utiliser avec set_param_min(), set_param_max(), et set_param_curve() pour définir les propriétés de vitesse orbitale.

Parameter PARAM_LINEAR_ACCEL = 3

À utiliser avec set_param_min(), set_param_max(), et set_param_curve() pour définir les propriétés d'accélération linéaire.

Parameter PARAM_RADIAL_ACCEL = 4

À utiliser avec set_param_min(), set_param_max(), et set_param_curve() pour définir les propriétés d'accélération radiale.

Parameter PARAM_TANGENTIAL_ACCEL = 5

À utiliser avec set_param_min(), set_param_max(), et set_param_curve() pour définir les propriétés d'accélération tangentielle.

Parameter PARAM_DAMPING = 6

À utiliser avec set_param_min(), set_param_max(), et set_param_curve() pour définir les propriétés d'amortissement.

Parameter PARAM_ANGLE = 7

À utiliser avec set_param_min(), set_param_max(), et set_param_curve() pour définir les propriétés d'angle.

Parameter PARAM_SCALE = 8

À utiliser avec set_param_min(), set_param_max(), et set_param_curve() pour définir les propriétés d'échelle.

Parameter PARAM_HUE_VARIATION = 9

À utiliser avec set_param_min(), set_param_max(), et set_param_curve() pour définir les propriétés de variation de teinte.

Parameter PARAM_ANIM_SPEED = 10

À utiliser avec set_param_min(), set_param_max(), et set_param_curve() pour définir les propriétés de vitesse d'animation.

Parameter PARAM_ANIM_OFFSET = 11

À utiliser avec set_param_min(), set_param_max(), et set_param_curve() pour définir les propriétés de décalage d'animation.

Parameter PARAM_MAX = 12

Représente la taille de l'énumération Parameter.

enum ParticleFlags: 🔗

ParticleFlags PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY = 0

Utilisez avec set_particle_flag() pour définir particle_flag_align_y.

ParticleFlags PARTICLE_FLAG_ROTATE_Y = 1

Présent pour des raisons de cohérence avec les nœuds de particules 3D, mais non utilisé en 2D.

ParticleFlags PARTICLE_FLAG_DISABLE_Z = 2

Présent pour des raisons de cohérence avec les nœuds de particules 3D, mais non utilisé en 2D.

ParticleFlags PARTICLE_FLAG_MAX = 3

Représente la taille de l'énumération ParticleFlags.

enum EmissionShape: 🔗

EmissionShape EMISSION_SHAPE_POINT = 0

Toutes les particules seront émises depuis un seul point.

EmissionShape EMISSION_SHAPE_SPHERE = 1

Les particules seront émises dans le volume d'une sphère aplatie en deux dimensions.

EmissionShape EMISSION_SHAPE_SPHERE_SURFACE = 2

Les particules seront émises à la surface d'une sphère aplatie en deux dimensions.

EmissionShape EMISSION_SHAPE_RECTANGLE = 3

Toutes les particules seront émises depuis l'aire d'un rectangle.

EmissionShape EMISSION_SHAPE_POINTS = 4

Les particules seront émises à une position choisie au hasard parmi les points emission_points. La couleur des particules sera modulée par emission_colors.

EmissionShape EMISSION_SHAPE_DIRECTED_POINTS = 5

Les particules seront émises à une position choisie au hasard parmi emission_points. La vitesse et la rotation des particules seront déterminées en fonction de emission_normals. La couleur des particules sera modulée par emission_colors.

EmissionShape EMISSION_SHAPE_RING = 6

Particles will be emitted in the area of a ring parameterized by its outer and inner radius.

EmissionShape EMISSION_SHAPE_MAX = 7

Représente la taille de l'énumération EmissionShape.

Descriptions des propriétés

int amount = 8 🔗

  • void set_amount(value: int)

  • int get_amount()

Nombre de particules émises dans un cycle d'émission.

Curve angle_curve 🔗

La rotation de chaque particule sera animée le long de cette Curve. Devrait être une Curve unitaire.

float angle_max = 0.0 🔗

Rotation initiale maximale appliquée à chaque particule, en degrés.

float angle_min = 0.0 🔗

Équivalent pour le minimum de angle_max.

Curve angular_velocity_curve 🔗

La vélocité angulaire de chaque particule variera le long de cette Curve. Devrait être une Curve unitaire.

float angular_velocity_max = 0.0 🔗

Vélocité maximale angulaire initiale (vitesse de rotation) appliquée à chaque particule en degrés par seconde.

float angular_velocity_min = 0.0 🔗

Équivalent pour le minimum de angular_velocity_max.

Curve anim_offset_curve 🔗

Le décalage d'animation de chaque particule variera le long de cette Curve. Devrait être une Curve unitaire.

float anim_offset_max = 0.0 🔗

Décalage d'animation maximum qui correspond à l'index de trame dans la texture. 0 est la première trame, 1 est la dernière. Voir CanvasItemMaterial.particles_animation.

float anim_offset_min = 0.0 🔗

Équivalent pour le minimum de anim_offset_max.

Curve anim_speed_curve 🔗

La vitesse d'animation de chaque particule variera le long de cette Curve. Devrait être une Curve unitaire.

float anim_speed_max = 0.0 🔗

Vitesse maximale d'animation des particules. Une vitesse d'animation de 1 signifie que les particules feront un cycle complet de 0 à 1 pendant leur durée de vie, 2 signifie `` 2`` cycles, etc...

Avec une vitesse d'animation supérieure à 1, rappelez-vous pour activer la propriété CanvasItemMaterial.particles_anim_loop si vous voulez que l'animation se répète.

float anim_speed_min = 0.0 🔗

Équivalent pour le minimum de anim_speed_max.

Color color = Color(1, 1, 1, 1) 🔗

La couleur initiale de chaque particule. Si texture est défini, les particules sont multipliées par cette couleur.

Gradient color_initial_ramp 🔗

  • void set_color_initial_ramp(value: Gradient)

  • Gradient get_color_initial_ramp()

Chaque couleur initiale de particule variera selon ce Gradient (multiplié avec color).

Gradient color_ramp 🔗

Chaque couleur de particule variera selon ce Gradient sur sa durée de vie (multiplié avec color).

Curve damping_curve 🔗

L'amortissement variera le long de cette Curve. Devrait être une Curve unitaire.

float damping_max = 0.0 🔗

La vitesse maximale à laquelle les particules perdent leur vitesse. Par exemple, une valeur de 100 signifie que la particule va de la vitesse 100 à 0 en 1 seconde.

float damping_min = 0.0 🔗

Équivalent pour le minimum de damping_max.

Vector2 direction = Vector2(1, 0) 🔗

Le vecteur unitaire définissant la direction d'émission des particules.

DrawOrder draw_order = 0 🔗

Ordre de dessin des particules.

PackedColorArray emission_colors 🔗

Définit les Color pour moduler les particules en utilisant EMISSION_SHAPE_POINTS ou EMISSION_SHAPE_DIRECTED_POINTS.

Note: The returned array is copied and any changes to it will not update the original property value. See PackedColorArray for more details.

PackedVector2Array emission_normals 🔗

Définit la direction des particules qui seront émises quand EMISSION_SHAPE_DIRECTED_POINTS est utilisé.

Note: The returned array is copied and any changes to it will not update the original property value. See PackedVector2Array for more details.

PackedVector2Array emission_points 🔗

Définit les positions initiales pour les particules créées en utilisant EMISSION_SHAPE_POINTS ou EMISSION_SHAPE_DIRECTED_POINTS.

Note: The returned array is copied and any changes to it will not update the original property value. See PackedVector2Array for more details.

Vector2 emission_rect_extents 🔗

  • void set_emission_rect_extents(value: Vector2)

  • Vector2 get_emission_rect_extents()

L'étendue du rectangle si emission_shape vaut EMISSION_SHAPE_RECTANGLE.

float emission_ring_inner_radius 🔗

  • void set_emission_ring_inner_radius(value: float)

  • float get_emission_ring_inner_radius()

The ring's inner radius if emission_shape is set to EMISSION_SHAPE_RING.

float emission_ring_radius 🔗

  • void set_emission_ring_radius(value: float)

  • float get_emission_ring_radius()

The ring's outer radius if emission_shape is set to EMISSION_SHAPE_RING.

EmissionShape emission_shape = 0 🔗

Les particules seront émises dans cette région.

float emission_sphere_radius 🔗

  • void set_emission_sphere_radius(value: float)

  • float get_emission_sphere_radius()

Le rayon de la sphère si emission_shape est EMISSION_SHAPE_SPHERE.

bool emitting = true 🔗

  • void set_emitting(value: bool)

  • bool is_emitting()

Si true, des particules sont émises. emitting peut être utilisé pour démarrer et arrêter l'émission des particules. Toutefois, si one_shot vaut true, définir emitting à true ne redémarrera pas le cycle d'émission jusqu'à ce que toutes les particules actives soient traitées. Vous pouvez utiliser le signal finished pour être notifié une fois que toutes les particules actives ont été traitées.

float explosiveness = 0.0 🔗

  • void set_explosiveness_ratio(value: float)

  • float get_explosiveness_ratio()

La rapidité avec laquelle les particules d’un cycle d’émission sont émises. Si elle est supérieure à 0, il y aura un écart dans les émissions avant le début du prochain cycle.

int fixed_fps = 0 🔗

  • void set_fixed_fps(value: int)

  • int get_fixed_fps()

Le taux de rafraîchissement du système de particules est fixé à une valeur. Par exemple, changer la valeur à 2 rendra les particules à 2 trames par seconde. Notez que cela ne ralentit pas la simulation du système de particules lui-même.

bool fract_delta = true 🔗

  • void set_fractional_delta(value: bool)

  • bool get_fractional_delta()

Si true, utilise un calcul d'étape fractionnelle qui permet affichage plus lisse des particules.

Vector2 gravity = Vector2(0, 980) 🔗

Gravité appliquée à chaque particule.

Curve hue_variation_curve 🔗

La teinte de chaque particule variera suivant cette Curve. Devrait être une Curve unitaire.

float hue_variation_max = 0.0 🔗

Variation de teinte initiale maximale appliquée à chaque particule. Cela va changer la teinte de la couleur de la particule.

float hue_variation_min = 0.0 🔗

Équivalent pour le minimum de hue_variation_max.

float initial_velocity_max = 0.0 🔗

Magnitude de la vélocité maximale appliquée à chaque particule. La direction provient de direction et spread.

float initial_velocity_min = 0.0 🔗

Équivalent pour le minimum de initial_velocity_max.

float lifetime = 1.0 🔗

  • void set_lifetime(value: float)

  • float get_lifetime()

La durée pendant laquelle chaque particule existera.

float lifetime_randomness = 0.0 🔗

  • void set_lifetime_randomness(value: float)

  • float get_lifetime_randomness()

Facteur d'aléatoire de la durée de vie d'une particule.

Curve linear_accel_curve 🔗

L'accélération linéaire de chaque particule variera suivant cette Curve. Devrait être une Curve unitaire.

float linear_accel_max = 0.0 🔗

Accélération linéaire maximale appliquée à chaque particule dans la direction du mouvement.

float linear_accel_min = 0.0 🔗

Équivalent pour le minimum de linear_accel_max.

bool local_coords = false 🔗

  • void set_use_local_coordinates(value: bool)

  • bool get_use_local_coordinates()

Si true, les particules utilisent l'espace de coordonnées du nœud parent (aussi appelées coordonnées locales). Cela causera les particules de se déplacer et tourner avec le nœud CPUParticles2D (et ses parents) lorsqu'il est déplacé ou tourné. Si false, les particules utilisent des coordonnées globales, cela ne causera pas les particules de se déplacer et tourner avec le nœud CPUParticles2D (et ses parents) lorsqu'il est déplacé ou en tourné.

bool one_shot = false 🔗

  • void set_one_shot(value: bool)

  • bool get_one_shot()

Si true, un seul cycle d'émission se produit. Si définit à true pendant un cycle, l'émission s'arrêtera à la fin de ce cycle.

Curve orbit_velocity_curve 🔗

La vitesse orbitale de chaque particule variera suivant cette Curve. Devrait être une Curve unitaire.

float orbit_velocity_max = 0.0 🔗

La vitesse orbitale maximale appliquée à chaque particule. Fait tourner les particules en cercle autour de l'origine. Spécifié en nombre de rotations complètes autour de l'origine par seconde.

float orbit_velocity_min = 0.0 🔗

Équivalent pour le minimum de orbit_velocity_max.

bool particle_flag_align_y = false 🔗

Aligner l’axe Y de la particule avec la direction de sa vélocité.

float preprocess = 0.0 🔗

  • void set_pre_process_time(value: float)

  • float get_pre_process_time()

Le système de particules démarre comme s'il avait déjà commencé depuis plusieurs secondes.

Curve radial_accel_curve 🔗

L'accélération radiale de chaque particule variera le long cette Curve. Devrait être une Curve unitaire.

float radial_accel_max = 0.0 🔗

Accélération radiale maximale appliquée à chaque particule. Fait accélérer les particules hors de l'origine, ou vers l'origine si elle est négative.

float radial_accel_min = 0.0 🔗

Équivalent pour le minimum de radial_accel_max.

float randomness = 0.0 🔗

  • void set_randomness_ratio(value: float)

  • float get_randomness_ratio()

Facteur d'aléatoire de durée de vie de l'émission.

Curve scale_amount_curve 🔗

L'échelle de chaque particule variera suivant cette Curve. Devrait être une Curve unitaire.

float scale_amount_max = 1.0 🔗

Échelle initiale maximale appliquée à chaque particule.

float scale_amount_min = 1.0 🔗

Équivalent pour le minimum de scale_amount_max.

Curve scale_curve_x 🔗

  • void set_scale_curve_x(value: Curve)

  • Curve get_scale_curve_x()

L'échelle horizontale de chaque particule variera suivant cette Curve. Devrait être une Curve unitaire.

split_scale doit être activé.

Curve scale_curve_y 🔗

  • void set_scale_curve_y(value: Curve)

  • Curve get_scale_curve_y()

L'échelle verticale de chaque particule variera suivant cette Curve. Devrait être une Curve unitaire.

split_scale doit être activé.

int seed = 0 🔗

  • void set_seed(value: int)

  • int get_seed()

Définit la graine de l'aléatoire utilisée par le système de particules. Seulement effectif si use_fixed_seed vaut true.

float speed_scale = 1.0 🔗

  • void set_speed_scale(value: float)

  • float get_speed_scale()

Le facteur de vitesse du système de particules. Une valeur de 0 peut être utilisée pour arrêter les particules.

bool split_scale = false 🔗

  • void set_split_scale(value: bool)

  • bool get_split_scale()

Si true, la courbe de l'échelle sera divisée en composantes x et y. Voir scale_curve_x et scale_curve_y.

float spread = 45.0 🔗

  • void set_spread(value: float)

  • float get_spread()

La direction initiale de chaque particules sera comprise entre +spread et -spread degrés.

Curve tangential_accel_curve 🔗

L'accélération tangentielle de chaque particule variera le long de cette Curve. Devrait être une Curve unitaire.

float tangential_accel_max = 0.0 🔗

L'accélération tangentielle maximale appliquée à chaque particule. L'accélération tangentielle est perpendiculaire à la vitesse de la particule, ce qui donne aux particules un mouvement de tourbillion.

float tangential_accel_min = 0.0 🔗

Équivalent pour le minimum de tangential_accel_max.

Texture2D texture 🔗

La texture des particules. Si null, les particules seront carrées.

bool use_fixed_seed = false 🔗

  • void set_use_fixed_seed(value: bool)

  • bool get_use_fixed_seed()

Si true, les particules utiliseront la même graine pour chaque simulation en utilisant la graine définie dans seed. Ceci est utile pour les situations où le résultat visuel devrait être consistant entre les replays, par exemple en utilisant le mode Création de film.

Descriptions des méthodes

void convert_from_particles(particles: Node) 🔗

Définit les propriétés de ce nœud pour correspondre au nœud GPUParticles2D donné avec un ParticleProcessMaterial assigné.

Curve get_param_curve(param: Parameter) const 🔗

Renvoie la Curve du paramètre spécifié par Parameter.

float get_param_max(param: Parameter) const 🔗

Renvoie la plage de valeur maximale pour le paramètre donné.

float get_param_min(param: Parameter) const 🔗

Renvoie la plage de valeur minimale pour le paramètre donné.

bool get_particle_flag(particle_flag: ParticleFlags) const 🔗

Renvoie l'état activé du drapeau de particules donné.

void request_particles_process(process_time: float, process_time_residual: float = 0.0) 🔗

Requests the particles to process for extra process time during a single frame.

process_time defines the time that the particles will process while emitting is on. process_time_residual defines the time that particles will process with emitting turned off for the simulation. When combined with speed_scale set to 0.0, this is useful to be able to seek a particle system timeline.

void restart(keep_seed: bool = false) 🔗

Redémarre l'émetteur de particules.

Si keep_seed vaut true, la graine aléatoire actuelle sera conservée. Utile pour l'avancement et la lecture.

void set_param_curve(param: Parameter, curve: Curve) 🔗

Définit la Curve du paramètre spécifié par Parameter. Devrait être une Curve unitaire.

void set_param_max(param: Parameter, value: float) 🔗

Définit la valeur maximale pour le paramètre donné.

void set_param_min(param: Parameter, value: float) 🔗

Définit la valeur minimale pour le paramètre donné.

void set_particle_flag(particle_flag: ParticleFlags, enable: bool) 🔗

Active ou désactive le drapeau de particule donné.