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...

CPUParticles3D

Hérite de : GeometryInstance3D < VisualInstance3D < Node3D < Node < Object

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

Description

Nœud de particules 3D basé sur le CPU utilisé pour créer de nombreux systèmes et effets de particules.

Voir aussi GPUParticles3D, qui fournit la même fonctionnalité avec l'accélération matérielle, mais peut ne pas fonctionner sur d'anciens appareils.

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

Vector3

direction

Vector3(1, 0, 0)

DrawOrder

draw_order

0

Vector3

emission_box_extents

PackedColorArray

emission_colors

PackedColorArray()

PackedVector3Array

emission_normals

PackedVector3Array

emission_points

Vector3

emission_ring_axis

float

emission_ring_cone_angle

float

emission_ring_height

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

float

flatness

0.0

bool

fract_delta

true

Vector3

gravity

Vector3(0, -9.8, 0)

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

Mesh

mesh

bool

one_shot

false

Curve

orbit_velocity_curve

float

orbit_velocity_max

float

orbit_velocity_min

bool

particle_flag_align_y

false

bool

particle_flag_disable_z

false

bool

particle_flag_rotate_y

false

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

Curve

scale_curve_z

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

bool

use_fixed_seed

false

AABB

visibility_aabb

AABB(0, 0, 0, 0, 0, 0)

Méthodes

AABB

capture_aabb() const

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.

DrawOrder DRAW_ORDER_VIEW_DEPTH = 2

Les particules sont affichées suivant leur profondeur à l'écran.

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

Utilisez avec set_particle_flag() pour définir particle_flag_rotate_y.

ParticleFlags PARTICLE_FLAG_DISABLE_Z = 2

Utilisez avec set_particle_flag() pour définir particle_flag_disable_z.

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

Toutes les particules seront émises depuis l'intérieur d'une sphère.

EmissionShape EMISSION_SHAPE_SPHERE_SURFACE = 2

Les particules seront émises à la surface d'une sphère.

EmissionShape EMISSION_SHAPE_BOX = 3

Toutes les particules seront émises depuis l'intérieur d'une boite.

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

Toutes les particules seront émises depuis un anneau ou un cylindre.

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 🔗

Angle maximum.

float angle_min = 0.0 🔗

Angle minimum.

Curve angular_velocity_curve 🔗

La vitesse angulaire de chaque particule (vitesse de rotation) variera le long de cette Curve au cours de sa vie. 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 🔗

La vitesse angulaire minimale (vitesse de rotation) appliquée à chaque particule en degrés par seconde.

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 maximum de l'animation.

float anim_offset_min = 0.0 🔗

Décalage minimum de l'animation.

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 d’animation maximale des particules.

float anim_speed_min = 0.0 🔗

Vitesse d’animation minimale des particules.

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

La couleur initiale de chaque particule.

Note : color multiplie les couleurs des sommets du maillage de la particule. Pour avoir un effet visible sur un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo doit valoir true. Pour un ShaderMaterial, ALBEDO *= COLOR.rgb; doit être inséré dans la fonction fragment() du shader. Sinon, color n'aura pas d'effet visible.

Gradient color_initial_ramp 🔗

  • void set_color_initial_ramp(value: Gradient)

  • Gradient get_color_initial_ramp()

La couleur initiale de chaque particule variera suivant ce Gradient (multiplié avec color).

Note : color_initial_ramp multiplie les couleurs des sommets du maillage de la particule. Pour avoir un effet visible sur un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo doit valoir true. Pour un ShaderMaterial, ALBEDO *= COLOR.rgb; doit être inséré dans la fonction fragment() du shader. Sinon, color_initial_ramp n'aura pas d'effet visible.

Gradient color_ramp 🔗

La couleur initiale de chaque particule variera suivant ce Gradient sur sa durée de vie (multiplié avec color).

Note : color_ramp multiplie les couleurs des sommets du maillage de la particule. Pour avoir un effet visible sur un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo doit valoir true. Pour un ShaderMaterial, ALBEDO *= COLOR.rgb; doit être inséré dans la fonction fragment() du shader. Sinon, color_ramp n'aura pas d'effet visible.

Curve damping_curve 🔗

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

float damping_max = 0.0 🔗

Amortissement maximum.

float damping_min = 0.0 🔗

Amortissement minimum.

Vector3 direction = Vector3(1, 0, 0) 🔗

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

DrawOrder draw_order = 0 🔗

Ordre de dessin des particules.

Vector3 emission_box_extents 🔗

  • void set_emission_box_extents(value: Vector3)

  • Vector3 get_emission_box_extents()

L'étendue du rectangle si emission_shape vaut EMISSION_SHAPE_BOX.

PackedColorArray emission_colors = PackedColorArray() 🔗

Définit les Colors avec lesquelles moduler les particules lors de l'utilisation de EMISSION_SHAPE_POINTS ou EMISSION_SHAPE_DIRECTED_POINTS.

Note : emission_colors multiplie les couleurs des sommets du maillage de la particule. Pour avoir un effet visible sur un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo doit valoir true. Pour un ShaderMaterial, ALBEDO *= COLOR.rgb; doit être inséré dans la fonction fragment() du shader. Sinon, emission_colors n'aura pas d'effet visible.

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

PackedVector3Array 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 PackedVector3Array for more details.

PackedVector3Array 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 PackedVector3Array for more details.

Vector3 emission_ring_axis 🔗

  • void set_emission_ring_axis(value: Vector3)

  • Vector3 get_emission_ring_axis()

L'axe de l'anneau pour l'émetteur EMISSION_SHAPE_RING.

float emission_ring_cone_angle 🔗

  • void set_emission_ring_cone_angle(value: float)

  • float get_emission_ring_cone_angle()

L'angle du cône lors de l'utilisation de l'émetteur EMISSION_SHAPE_RING. L'angle par défaut de 90 degrés résulte en un anneau, tandis qu'un angle de 0 degré résulte en un cône. Les valeurs intermédiaires se traduiront par une anneau où une extrémité est plus grande que l'autre.

Note : Selon emission_ring_height, l'angle peut être borné si l'extrémité de l'anneau est atteinte pour former un cône parfait.

float emission_ring_height 🔗

  • void set_emission_ring_height(value: float)

  • float get_emission_ring_height()

La hauteur de l'anneau pour l'émetteur EMISSION_SHAPE_RING.

float emission_ring_inner_radius 🔗

  • void set_emission_ring_inner_radius(value: float)

  • float get_emission_ring_inner_radius()

Le rayon intérieur de l'anneau pour l'émetteur EMISSION_SHAPE_RING.

float emission_ring_radius 🔗

  • void set_emission_ring_radius(value: float)

  • float get_emission_ring_radius()

Le rayon de l'anneau pour l'émetteur 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 sphere si EmissionShape 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 le système de particules lui-même.

float flatness = 0.0 🔗

  • void set_flatness(value: float)

  • float get_flatness()

La quantité d'éparpillement spread dans le plan Y/Z. Une valeur de 1 limite les particules au plan X/Z.

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.

Vector3 gravity = Vector3(0, -9.8, 0) 🔗

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 maximum.

float hue_variation_min = 0.0 🔗

Variation de teinte minimum.

float initial_velocity_max = 0.0 🔗

Valeur maximale pour la vitesse initiale.

float initial_velocity_min = 0.0 🔗

Valeur minimale pour la vitesse initiale.

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.

float linear_accel_min = 0.0 🔗

Accélération linéaire minimum.

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 CPUParticles3D (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 CPUParticles3D (et ses parents) lorsqu'il est déplacé ou en tourné.

Mesh mesh 🔗

  • void set_mesh(value: Mesh)

  • Mesh get_mesh()

Le Mesh utilisé pour chaque particule. Si null, les particules seront des sphères.

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 🔗

Vélocité d'orbite maximum.

float orbit_velocity_min 🔗

Vélocité d'orbite minimum.

bool particle_flag_align_y = false 🔗

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

bool particle_flag_disable_z = false 🔗

Si true, les particules ne se déplaceront pas le long de l'axe Z.

bool particle_flag_rotate_y = false 🔗

Si true, les particules pivoteront autour de l'axe Y de angle_min.

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.

float radial_accel_min = 0.0 🔗

Accélération radiale minimal.

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 maximale.

float scale_amount_min = 1.0 🔗

Échelle minimale.

Curve scale_curve_x 🔗

  • void set_scale_curve_x(value: Curve)

  • Curve get_scale_curve_x()

Courbe pour l'échelle au cours de la vie, le long de l'axe x.

Curve scale_curve_y 🔗

  • void set_scale_curve_y(value: Curve)

  • Curve get_scale_curve_y()

Courbe pour l'échelle au cours de la vie, le long de l'axe y.

Curve scale_curve_z 🔗

  • void set_scale_curve_z(value: Curve)

  • Curve get_scale_curve_z()

Courbe pour l'échelle au cours de la vie, le long de l'axe z.

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, trois courbes d'échelle différentes peuvent être spécifiés, une par axe.

float spread = 45.0 🔗

  • void set_spread(value: float)

  • float get_spread()

La direction initiale de chaque particule dans l'intervalle de +spread à -spread degrés. Appliquée aux plans sur X/Z et aux plans sur Y/Z.

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 🔗

Accélération tangentielle maximale.

float tangential_accel_min = 0.0 🔗

Accélération tangentielle minimale.

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.

AABB visibility_aabb = AABB(0, 0, 0, 0, 0, 0) 🔗

  • void set_visibility_aabb(value: AABB)

  • AABB get_visibility_aabb()

La AABB qui détermine la région du nœud qui doit être visible à l'écran pour que le système de particules soit actif.

Agrandissez la boîte si les particules apparaissent/disparaissent soudainement lorsque le nœud entre/sort de l'écran. La AABB peut être agrandie par code ou avec l'outil de l'éditeur Particules → Générer AABB.

Descriptions des méthodes

AABB capture_aabb() const 🔗

Renvoie la boîte délimitante alignée sur les axes qui contient toutes les particules qui sont actives dans la trame actuelle.

void convert_from_particles(particles: Node) 🔗

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

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é.