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...
ParticleProcessMaterial
Hérite de : Material < Resource < RefCounted < Object
Contient une configuration de particule pour les nœuds GPUParticles2D ou GPUParticles3D.
Description
ParticleProcessMaterial définit les propriétés et le comportement d'une particule. Il est utilisé dans les nœuds process_material des nœuds GPUParticles2D et GPUParticles3D. Certaines propriétés de ce matériau sont appliquées à chaque particule lorsqu'elles sont émises, tandis que d'autres peuvent avoir une CurveTexture ou une GradientTexture1D appliquées pour faire varier les valeurs numériques ou de couleur au cours de la durée de vie de la particule.
Propriétés
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Méthodes
get_param_max(param: Parameter) const |
|
get_param_min(param: Parameter) const |
|
get_param_texture(param: Parameter) const |
|
get_particle_flag(particle_flag: ParticleFlags) const |
|
void |
|
void |
set_param_max(param: Parameter, value: float) |
void |
set_param_min(param: Parameter, value: float) |
void |
set_param_texture(param: Parameter, texture: Texture2D) |
void |
set_particle_flag(particle_flag: ParticleFlags, enable: bool) |
Signaux
emission_shape_changed() 🔗
Émis lorsque la forme d'émission de ce matériau est modifiée de quelque manière que ce soit. Cela comprend les modifications à emission_shape, emission_shape_scale, ou emission_sphere_radius, et toute autre propriété qui affecte le décalage, la taille, l'échelle ou l'orientation de la forme d'émission.
Note : Ce signal n'est émis que dans l'éditeur pour des raisons de performance.
Énumérations
enum Parameter: 🔗
Parameter PARAM_INITIAL_LINEAR_VELOCITY = 0
À utiliser avec set_param_min(), set_param_max(), et set_param_texture() pour définir les propriétés de la vitesse initiale.
Parameter PARAM_ANGULAR_VELOCITY = 1
À utiliser avec set_param_min(), set_param_max(), et set_param_texture() pour définir les propriétés de la vitesse angulaire.
Parameter PARAM_ORBIT_VELOCITY = 2
À utiliser avec set_param_min(), set_param_max(), et set_param_texture() 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_texture() pour définir les propriétés de l'accélération linéaire.
Parameter PARAM_RADIAL_ACCEL = 4
À utiliser avec set_param_min(), set_param_max(), et set_param_texture() pour définir les propriétés de l'accélération radiale.
Parameter PARAM_TANGENTIAL_ACCEL = 5
À utiliser avec set_param_min(), set_param_max(), et set_param_texture() pour définir les propriétés de l'accélération tangentielle.
Parameter PARAM_DAMPING = 6
À utiliser avec set_param_min(), set_param_max(), et set_param_texture() pour définir les propriétés d'amortissement.
Parameter PARAM_ANGLE = 7
À utiliser avec set_param_min(), set_param_max(), et set_param_texture() pour définir les propriétés angulaires.
Parameter PARAM_SCALE = 8
À utiliser avec set_param_min(), set_param_max(), et set_param_texture() pour définir les propriétés de mise à l'échelle.
Parameter PARAM_HUE_VARIATION = 9
À utiliser avec set_param_min(), set_param_max(), et set_param_texture() 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_texture() pour définir les propriétés de la vitesse d'animation.
Parameter PARAM_ANIM_OFFSET = 11
À utiliser avec set_param_min(), set_param_max(), et set_param_texture() pour définir les propriétés du décalage de l'animation.
Parameter PARAM_RADIAL_VELOCITY = 15
À utiliser avec set_param_min(), set_param_max(), et set_param_texture() pour définir les propriétés de vitesse radiale.
Parameter PARAM_DIRECTIONAL_VELOCITY = 16
À utiliser avec set_param_min(), set_param_max(), et set_param_texture() pour définir les propriétés de vitesse directionnelle.
Parameter PARAM_SCALE_OVER_VELOCITY = 17
À utiliser avec set_param_min(), set_param_max(), et set_param_texture() pour définir les propriétés de l'échelle selon la vitesse.
Parameter PARAM_MAX = 18
Représente la taille de l'énumération Parameter.
Parameter PARAM_TURB_VEL_INFLUENCE = 13
À utiliser avec set_param_min(), set_param_max(), et set_param_max() pour définir l'influence minimale et maximale de la turbulence sur la vitesse de chaque particule.
Parameter PARAM_TURB_INIT_DISPLACEMENT = 14
À utiliser avec set_param_min() and set_param_max() pour définir le déplacement minimal et maximale de la turbulence sur la position d'apparition des particules.
Parameter PARAM_TURB_INFLUENCE_OVER_LIFE = 12
À utiliser avec set_param_texture() pour définir l'influence de la turbulence au cours de la durée de vie de la particule.
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_DAMPING_AS_FRICTION = 3
There is currently no description for this enum. Please help us by contributing one!
ParticleFlags PARTICLE_FLAG_INHERIT_EMITTER_SCALE = 4
There is currently no description for this enum. Please help us by contributing one!
ParticleFlags PARTICLE_FLAG_MAX = 5
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 déterminée en échantillonnant un point aléatoire sur emission_point_texture. La couleur des particules sera modulée par emission_color_texture.
EmissionShape EMISSION_SHAPE_DIRECTED_POINTS = 5
Les particules seront émises à une position déterminée en échantillonnant un point aléatoire sur emission_point_texture. La vitesse et la rotation de la particule seront définies selon emission_normal_texture. La couleur des particules sera modulée par emission_color_texture.
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.
enum SubEmitterMode: 🔗
SubEmitterMode SUB_EMITTER_DISABLED = 0
The subemitter is disabled.
SubEmitterMode SUB_EMITTER_CONSTANT = 1
The submitter is emitted on the constant interval defined by sub_emitter_frequency.
SubEmitterMode SUB_EMITTER_AT_END = 2
The subemitter is emitted at the end of the particle's lifetime.
SubEmitterMode SUB_EMITTER_AT_COLLISION = 3
The subemitter is emitted when the particle collides.
SubEmitterMode SUB_EMITTER_AT_START = 4
The subemitter is emitted when the particle spawns.
SubEmitterMode SUB_EMITTER_MAX = 5
Représente la taille de l'énumération SubEmitterMode.
enum CollisionMode: 🔗
CollisionMode COLLISION_DISABLED = 0
Pas de collision pour les particules. Les particules traverseront les nœuds GPUParticlesCollision3D.
CollisionMode COLLISION_RIGID = 1
Collision de type RigidBody3D pour les particules utilisant des nœuds GPUParticlesCollision3D.
CollisionMode COLLISION_HIDE_ON_CONTACT = 2
Cacher les particules instantanément lors de la collision avec un nœud GPUParticlesCollision3D. Cela peut être combiné avec un sous-émetteur qui utilise le mode de collision COLLISION_RIGID pour « remplacer » la particule parente par le sous-émetteur lors de l'impact.
CollisionMode COLLISION_MAX = 3
Représente la taille de l'énumération CollisionMode.
Descriptions des propriétés
La valeur alpha de la couleur de chaque particule sera multipliée par cette CurveTexture au cours de sa durée de vie.
Note : alpha_curve 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, ALPHA *= COLOR.a; doit être inséré dans la fonction fragment() du shader. Sinon, alpha_curve n'aura pas d'effet visible.
La rotation de chaque particule sera animé suivant cette CurveTexture.
Rotation initiale maximale appliquée à chaque particule, en degrés.
Seulement appliquée lorsque particle_flag_disable_z ou particle_flag_rotate_y vaillent true ou que le BaseMaterial3D utilisé pour dessiner la particule utilise BaseMaterial3D.BILLBOARD_PARTICLES.
Équivalent pour le minimum de angle_max.
Texture2D angular_velocity_curve 🔗
La vitesse angulaire (vitesse de rotation) de chaque particule variera suivant cette CurveTexture au cours de sa durée de vie.
float angular_velocity_max = 0.0 🔗
Vitesse angulaire (vitesse de rotation) initiale maximale appliquée à chaque particule, en degrés par seconde.
Seulement appliquée lorsque particle_flag_disable_z ou particle_flag_rotate_y vaillent true ou que le BaseMaterial3D utilisé pour dessiner la particule utilise BaseMaterial3D.BILLBOARD_PARTICLES.
float angular_velocity_min = 0.0 🔗
Équivalent pour le minimum de angular_velocity_max.
La position de l'animation de chaque particule variera suivant cette CurveTexture.
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.
Équivalent pour le minimum de anim_offset_max.
La vitesse d'animation de chaque particule variera suivant cette CurveTexture.
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.
Équivalent pour le minimum de anim_speed_max.
bool attractor_interaction_enabled = true 🔗
Si true, l'interaction avec les attracteurs de particules est activée. En 3D, l'attraction ne se produit que dans la zone définie par la GPUParticles3D.visibility_aabb du nœud GPUParticles3D.
La bouciness des particules. Les valeurs vont de 0 (pas de rebond) à 1 (rebond complet). Seulement effectif si collision_mode vaut COLLISION_RIGID.
La friction des particules. Les valeurs vont de 0 (sans friction) à 1 (friction maximale). Seulement effectif si collision_mode vaut COLLISION_RIGID.
CollisionMode collision_mode = 0 🔗
void set_collision_mode(value: CollisionMode)
CollisionMode get_collision_mode()
Le mode de collision des particules.
Note : Les particules 3D ne peuvent entrer en collision qu'avec des nœuds GPUParticlesCollision3D, pas des nœuds PhysicsBody3D. Pour faire entrer en collision des particules avec divers objets, vous pouvez ajouter des nœuds GPUParticlesCollision3D comme enfants de nœuds PhysicsBody3D. En 3D, les collisions ne se produisent que dans la zone définie par la GPUParticles3D.visibility_aabb du nœud GPUParticles3D.
Note : Les particules 2D ne peuvent entrer en collision qu'avec des nœuds LightOccluder2D, pas les nœuds PhysicsBody2D.
bool collision_use_scale = false 🔗
Si true, GPUParticles3D.collision_base_size est multipliée par l'échelle effective de la particule (voir scale_min, scale_max, scale_curve, et scale_over_velocity_curve).
Color color = Color(1, 1, 1, 1) 🔗
La couleur initiale de chaque particule. Si la texture de GPUParticles2D est définie, elle sera multipliée par cette couleur.
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.
Texture2D color_initial_ramp 🔗
La couleur initiale de chaque particule variera selon ce GradientTexture1D (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.
La couleur initiale de chaque particule variera suivant ce GradientTexture1D 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.
L’amortissement variera le long de cette CurveTexture.
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.
Équivalent pour le minimum de damping_max.
Vector3 direction = Vector3(1, 0, 0) 🔗
Le vecteur unitaire définissant la direction d'émission des particules.
Texture2D directional_velocity_curve 🔗
Une courbe qui spécifie la vitesse le long de chacun des axes du système de particules au cours de sa durée de vie.
Note : Les vitesses animées ne seront pas affectées par l'amortissement, utilisez plutôt velocity_limit_curve.
float directional_velocity_max 🔗
Valeur de la vitesse directionnelle maximale, qui est multipliée par directional_velocity_curve.
Note : Les vitesses animées ne seront pas affectées par l'amortissement, utilisez plutôt velocity_limit_curve.
float directional_velocity_min 🔗
Valeur de la vitesse directionnelle minimale, qui est multipliée par directional_velocity_curve.
Note : Les vitesses animées ne seront pas affectées par l'amortissement, utilisez plutôt velocity_limit_curve.
Vector3 emission_box_extents 🔗
L'étendue de la boîte si emission_shape est définie à EMISSION_SHAPE_BOX.
Note : emission_box_extents démarre du point central et applique les valeurs X, Y et Z dans les deux directions. La taille vaut deux fois l'aire de l'étendue.
Texture2D emission_color_texture 🔗
La couleur des particules sera modulée par la couleur déterminée en échantillonnant cette texture au même point que emission_point_texture.
Note : emission_color_texture 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_color_texture n'aura pas d'effet visible.
La couleur de chaque particule sera multipliée par cette CurveTexture au cours de sa durée de vie.
Note : emission_curve 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_curve n'aura pas d'effet visible.
Texture2D emission_normal_texture 🔗
La vitesse et la rotation des particules seront définies en échantillonnant cette texture au même point que le emission_point_texture. Utilisé uniquement dans EMISSION_SHAPE_DIRECTED_POINTS. Peut être créée automatiquement à partir de maillages ou de nœuds en sélectionnant "Créer points d'émission à partir d'un maillage/Nœud" sous l'outil "Particules" dans la barre d'outils.
Le nombre de points d'émission si emission_shape vaut EMISSION_SHAPE_POINTS ou EMISSION_SHAPE_DIRECTED_POINTS.
Texture2D emission_point_texture 🔗
Les particules seront émises aux positions déterminées en échantillonnant cette texture à une position aléatoire. Utilisé avec EMISSION_SHAPE_POINTS et EMISSION_SHAPE_DIRECTED_POINTS. Peut être créé automatiquement à partir d'un maillage ou d'un nœud en sélectionnant "Créer points d'émission à partir d'un maillage/Nœud" sous l'outil "Particles" dans la barre d'outils.
L'axe de l'anneau pour l'émetteur EMISSION_SHAPE_RING.
float 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.
La hauteur de l'anneau pour l'émetteur EMISSION_SHAPE_RING.
float emission_ring_inner_radius 🔗
Le rayon intérieur de l'anneau pour l'émetteur EMISSION_SHAPE_RING.
Le rayon de l'anneau pour l'émetteur EMISSION_SHAPE_RING.
EmissionShape emission_shape = 0 🔗
void set_emission_shape(value: EmissionShape)
EmissionShape get_emission_shape()
Les particules seront émises dans cette région.
Vector3 emission_shape_offset = Vector3(0, 0, 0) 🔗
Le décalage pour emission_shape, dans l'espace local.
Vector3 emission_shape_scale = Vector3(1, 1, 1) 🔗
L'échelle de emission_shape, dans l'espace local.
float emission_sphere_radius 🔗
Le rayon de la sphère si emission_shape est EMISSION_SHAPE_SPHERE.
La quantité de diffusion spread le long de l'axe Y.
Vector3 gravity = Vector3(0, -9.8, 0) 🔗
Gravité appliquée à chaque particule.
Texture2D hue_variation_curve 🔗
La teinte de chaque particule variera suivant cette CurveTexture.
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 inherit_velocity_ratio = 0.0 🔗
Pourcentage de la vitesse du GPUParticles2D ou GPUParticles3D respectif héritée par chaque particule lors de son apparition.
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_randomness = 0.0 🔗
Facteur de l'aléatoire pour la durée de vie des particules. L'équation pour la durée de vie d'une particule est lifetime * (1.0 - randf() * lifetime_randomness). Par exemple, un lifetime_randomness de 0.4 dimensionne la durée de vie entre 0.6 à 1.0 de sa valeur originale.
Texture2D linear_accel_curve 🔗
La vitesse linéaire de chaque particule variera suivant cette CurveTexture.
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.
Texture2D orbit_velocity_curve 🔗
La vitesse orbitale de chaque particule variera suivant cette CurveTexture.
Note : Pour la vitesse orbitale 3D, utilisez une CurveXYZTexture.
Note : Les vitesses animées ne seront pas affectées par l'amortissement, utilisez plutôt velocity_limit_curve.
float orbit_velocity_max = 0.0 🔗
Vitesse orbitale maximale appliquée à chaque particule. Fait tourner les particules autour de l'origine. Spécifié en nombre de rotations complètes autour de l'origine par seconde.
Note : Les vitesses animées ne seront pas affectées par l'amortissement, utilisez plutôt velocity_limit_curve.
float orbit_velocity_min = 0.0 🔗
Équivalent pour le minimum de orbit_velocity_max.
Note : Les vitesses animées ne seront pas affectées par l'amortissement, utilisez plutôt velocity_limit_curve.
bool particle_flag_align_y = false 🔗
void set_particle_flag(particle_flag: ParticleFlags, enable: bool)
bool get_particle_flag(particle_flag: ParticleFlags) const
Aligner l’axe Y de la particule avec la direction de sa vélocité.
bool particle_flag_damping_as_friction = false 🔗
void set_particle_flag(particle_flag: ParticleFlags, enable: bool)
bool get_particle_flag(particle_flag: ParticleFlags) const
Change le comportement des propriétés d'amortissement d'une décélération linéaire en une décélération basée sur un pourcentage de la vitesse.
bool particle_flag_disable_z = false 🔗
void set_particle_flag(particle_flag: ParticleFlags, enable: bool)
bool get_particle_flag(particle_flag: ParticleFlags) const
Si true, les particules ne se déplaceront pas le long de l'axe Z.
bool particle_flag_inherit_emitter_scale = false 🔗
void set_particle_flag(particle_flag: ParticleFlags, enable: bool)
bool get_particle_flag(particle_flag: ParticleFlags) const
If true, particles will inherit the scale of the emitter.
Note: This has no effect when GPUParticles3D.local_coords is true, since particles in local space are already affected by the emitter's scale.
bool particle_flag_rotate_y = false 🔗
void set_particle_flag(particle_flag: ParticleFlags, enable: bool)
bool get_particle_flag(particle_flag: ParticleFlags) const
Si true, les particules pivoteront autour de l'axe Y de angle_min.
Texture2D radial_accel_curve 🔗
L'accélération radiale de chaque particule variera suivant cette CurveTexture.
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.
Texture2D radial_velocity_curve 🔗
A CurveTexture that defines the velocity over the particle's lifetime away (or toward) the velocity_pivot.
Note: Animated velocities will not be affected by damping, use velocity_limit_curve instead.
float radial_velocity_max = 0.0 🔗
Vitesse radiale maximale appliquée à chaque particule. Fait que les particules s’éloignent de velocity_pivot, ou s'en approchent si négative.
Note : Les vitesses animées ne seront pas affectées par l'amortissement, utilisez plutôt velocity_limit_curve.
float radial_velocity_min = 0.0 🔗
Vitesse radiale minimale appliquée à chaque particule. Fait que les particules s’éloignent de velocity_pivot, ou s'en approchent si négative.
Note : Les vitesses animées ne seront pas affectées par l'amortissement, utilisez plutôt velocity_limit_curve.
The maximum 3D orientation, in degrees. Works only in 3D and if use_rotation_3d is enabled.
The minimum 3D orientation, in degrees. Works only in 3D and if use_rotation_3d is enabled.
Texture2D rotation_velocity_3d_curve 🔗
Rotation velocity curve over lifetime, per-axis. Enable use_rotation_velocity_3d to use this.
Vector3 rotation_velocity_3d_max 🔗
Maximum 3D rotation velocity on the particle's local axis. Enable use_rotation_velocity_3d to use this.
Vector3 rotation_velocity_3d_min 🔗
Minimum 3D rotation velocity on the particle's local axis. Enable use_rotation_velocity_3d to use this.
The maximum value of the random scale vector for each particle.
Works only if use_scale_3d is enabled.
The minimum value of the random scale vector for each particle.
Works only if use_scale_3d is enabled.
L'échelle de chaque particule variera suivant cette CurveTexture durant sa durée de vie. Si une CurveXYZTexture est fournie à la place, l'échelle sera séparée par axe.
Échelle initiale maximale appliquée à chaque particule.
Équivalent pour le minimum de scale_max.
Texture2D scale_over_velocity_curve 🔗
Soit une CurveTexture ou une CurveXYZTexture qui dimensionne chaque particule en fonction de sa vitesse.
float scale_over_velocity_max = 0.0 🔗
Référence de la valeur de vitesse maximale pour scale_over_velocity_curve.
scale_over_velocity_curve sera interpolée entre scale_over_velocity_min et scale_over_velocity_max.
float scale_over_velocity_min = 0.0 🔗
Référence de la valeur de vitesse minimale pour scale_over_velocity_curve.
scale_over_velocity_curve sera interpolée entre scale_over_velocity_min et scale_over_velocity_max.
La direction initiale de chaque particules sera comprise entre +spread et -spread degrés.
int sub_emitter_amount_at_collision 🔗
La quantité de particules apparaissant du nœud sous-émetteur lorsqu'une collision survient. Lorsque combiné avec COLLISION_HIDE_ON_CONTACT sur le matériau des particules principales, cela peut être utilisé pour réaliser des effets tels que des gouttes de pluie frappant le sol.
Note : Cette valeur ne doit pas dépasser GPUParticles2D.amount ou GPUParticles3D.amount défini sur le nœud sous-émetteur (pas le nœud principal), par rapport à la durée de vie des particules du sous-émetteur. Si le nombre de particules est dépassé, aucune nouvelle particule n'apparaîtra du sous-émetteur jusqu'à ce que suffisamment de particules aient expiré.
int sub_emitter_amount_at_end 🔗
La quantité de particules apparaissant du nœud sous-émetteur lorsque la particule expire.
Note : Cette valeur ne doit pas dépasser GPUParticles2D.amount ou GPUParticles3D.amount défini sur le nœud sous-émetteur (pas le nœud principal), par rapport à la durée de vie des particules du sous-émetteur. Si le nombre de particules est dépassé, aucune nouvelle particule n'apparaîtra du sous-émetteur jusqu'à ce que suffisamment de particules aient expiré.
int sub_emitter_amount_at_start 🔗
La quantité de particules apparaissant du nœud sous-émetteur lorsque la particule apparaît.
Note : Cette valeur ne doit pas dépasser GPUParticles2D.amount ou GPUParticles3D.amount défini sur le nœud sous-émetteur (pas le nœud principal), par rapport à la durée de vie des particules du sous-émetteur. Si le nombre de particules est dépassé, aucune nouvelle particule n'apparaîtra du sous-émetteur jusqu'à ce que suffisamment de particules aient expiré.
La fréquence à laquelle les particules devraient être émises du nœud sous-émetteur. Une particule apparaîtra toutes les sub_emitter_frequency secondes.
Note : Cette valeur ne doit pas dépasser GPUParticles2D.amount ou GPUParticles3D.amount défini sur le nœud sous-émetteur (pas le nœud principal), par rapport à la durée de vie des particules du sous-émetteur. Si le nombre de particules est dépassé, aucune nouvelle particule n'apparaîtra du sous-émetteur jusqu'à ce que suffisamment de particules aient expiré.
bool sub_emitter_keep_velocity = false 🔗
Si true, le sous-émetteur hérite de la vitesse de la particule parente lorsqu'il apparaît.
SubEmitterMode sub_emitter_mode = 0 🔗
void set_sub_emitter_mode(value: SubEmitterMode)
SubEmitterMode get_sub_emitter_mode()
Le mode de sous-émetteur de particules (voir GPUParticles2D.sub_emitter et GPUParticles3D.sub_emitter).
Texture2D tangential_accel_curve 🔗
L'accélération tangentielle de chaque particule variera suivant cette CurveTexture.
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.
bool turbulence_enabled = false 🔗
Si true, active la turbulence pour le système de particules. La turbulence peut être utilisée pour faire varier le mouvement d'une particule en fonction de sa position (selon sur un motif de bruit 3D). En 3D, GPUParticlesAttractorVectorField3D avec NoiseTexture3D peut être utilisé comme alternative à une turbulence qui fonctionne dans l'espace global et avec plusieurs systèmes de particules réagissant de la même manière.
Note : Activer la turbulence a un coût élevé de performances sur le GPU. N'activez la turbulence que sur quelques systèmes de particules à la fois au maximum, et envisagez de la désactiver lorsque vous ciblez les plateformes mobiles/web.
float turbulence_influence_max = 0.1 🔗
Influence maximale de la turbulence sur chaque particule.
La quantité réelle d'influence de la turbulence sur chaque particule est calculée en tant que valeur aléatoire entre turbulence_influence_min et turbulence_influence_max et est multipliée par la quantité d'influence de la turbulence de turbulence_influence_over_life.
float turbulence_influence_min = 0.1 🔗
Influence minimale de la turbulence sur chaque particule.
La quantité réelle d'influence de la turbulence sur chaque particule est calculée en tant que valeur aléatoire entre turbulence_influence_min et turbulence_influence_max et est multipliée par la quantité d'influence de la turbulence de turbulence_influence_over_life.
Texture2D turbulence_influence_over_life 🔗
La quantité de turbulence avec chaque particule sera influencée le long de cette CurveTexture au cous de sa durée de vie.
float turbulence_initial_displacement_max = 0.0 🔗
Déplacement maximal de la position d'apparition de chaque particule par la turbulence.
La quantité réelle de déplacement sera un facteur de la turbulence sous-jacente multipliée par une valeur aléatoire entre turbulence_initial_displacement_min et turbulence_initial_displacement_max.
float turbulence_initial_displacement_min = 0.0 🔗
Déplacement minimal de la position d'apparition de chaque particule par la turbulence.
La quantité réelle de déplacement sera un facteur de la turbulence sous-jacente multipliée par une valeur aléatoire entre turbulence_initial_displacement_min et turbulence_initial_displacement_max.
float turbulence_noise_scale = 9.0 🔗
Cette valeur contrôle l'échelle/la fréquence globale du motif du bruit de la turbulence.
Une petite échelle résultera en des caractéristiques plus petites avec plus de détails tandis qu'une grande échelle résultera en un bruit plus doux avec des caractéristiques plus grandes.
Vector3 turbulence_noise_speed = Vector3(0, 0, 0) 🔗
Une vitesse de défilement pour le champ de turbulence. Cela définit une tendance directionnelle pour le déplacement du motif au cours du temps.
La valeur par défaut de Vector3(0, 0, 0) désactive le défilement.
float turbulence_noise_speed_random = 0.2 🔗
The in-place rate of change of the turbulence field. This defines how quickly the noise pattern varies over time.
A value of 0.0 will result in a fixed pattern.
float turbulence_noise_strength = 1.0 🔗
The turbulence noise strength. Increasing this will result in a stronger, more contrasting, flow pattern.
bool use_rotation_3d = false 🔗
Enable the usage of rotation_3d_min and rotation_3d_max.
bool use_rotation_velocity_3d = false 🔗
Enable 3D rotation velocity.
Enable the usage of scale_3d_min and scale_3d_max.
Texture2D velocity_limit_curve 🔗
Une CurveTexture qui définit la vitesse maximale d'une particule au cours de sa durée de vie.
Vector3 velocity_pivot = Vector3(0, 0, 0) 🔗
Un point de pivot utilisé pour calculer la vitesse radiale et orbitale des particules.
Descriptions des méthodes
Vector2 get_param(param: Parameter) const 🔗
Renvoie les valeurs minimales et maximales du paramètre param donné en tant que vecteur.
La composante x du vecteur renvoyé correspond au minimum et la composante y correspond au maximum.
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é.
Texture2D get_param_texture(param: Parameter) const 🔗
Renvoie la Texture2D utilisée par le paramètre spécifié.
bool get_particle_flag(particle_flag: ParticleFlags) const 🔗
Renvoie true si le drapeau de particule spécifié est activé.
void set_param(param: Parameter, value: Vector2) 🔗
Définit les valeurs minimales et maximales du paramètre param donné.
La composante x du vecteur de l'argument correspond au minimum et la composante y correspond au maximum.
void set_param_max(param: Parameter, value: float) 🔗
Définit la valeur de plage maximale pour le paramètre donné.
void set_param_min(param: Parameter, value: float) 🔗
Définit la valeur de plage minimale pour le paramètre donné.
void set_param_texture(param: Parameter, texture: Texture2D) 🔗
Définit la Texture2D pour le paramètre Parameter spécifié.
void set_particle_flag(particle_flag: ParticleFlags, enable: bool) 🔗
Définit particle_flag à enable.