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

Eredita: Material < Resource < RefCounted < Object

Contiene una configurazione di particelle per i nodi GPUParticles2D o GPUParticles3D.

Descrizione

ParticleProcessMaterial definisce le proprietà e il comportamento delle particelle. È utilizzato nel process_material dei nodi GPUParticles2D e GPUParticles3D. Alcune delle proprietà di questo materiale vengono applicate a ciascuna particella quando viene emessa, mentre altre possono avere una CurveTexture o una GradientTexture1D applicata per variare i valori numerici o di colore durante la durata della particella.

Proprietà

Texture2D

alpha_curve

Texture2D

angle_curve

float

angle_max

0.0

float

angle_min

0.0

Texture2D

angular_velocity_curve

float

angular_velocity_max

0.0

float

angular_velocity_min

0.0

Texture2D

anim_offset_curve

float

anim_offset_max

0.0

float

anim_offset_min

0.0

Texture2D

anim_speed_curve

float

anim_speed_max

0.0

float

anim_speed_min

0.0

bool

attractor_interaction_enabled

true

float

collision_bounce

float

collision_friction

CollisionMode

collision_mode

0

bool

collision_use_scale

false

Color

color

Color(1, 1, 1, 1)

Texture2D

color_initial_ramp

Texture2D

color_ramp

Texture2D

damping_curve

float

damping_max

0.0

float

damping_min

0.0

Vector3

direction

Vector3(1, 0, 0)

Texture2D

directional_velocity_curve

float

directional_velocity_max

float

directional_velocity_min

Vector3

emission_box_extents

Texture2D

emission_color_texture

Texture2D

emission_curve

Texture2D

emission_normal_texture

int

emission_point_count

Texture2D

emission_point_texture

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

Vector3

emission_shape_offset

Vector3(0, 0, 0)

Vector3

emission_shape_scale

Vector3(1, 1, 1)

float

emission_sphere_radius

float

flatness

0.0

Vector3

gravity

Vector3(0, -9.8, 0)

Texture2D

hue_variation_curve

float

hue_variation_max

0.0

float

hue_variation_min

0.0

float

inherit_velocity_ratio

0.0

float

initial_velocity_max

0.0

float

initial_velocity_min

0.0

float

lifetime_randomness

0.0

Texture2D

linear_accel_curve

float

linear_accel_max

0.0

float

linear_accel_min

0.0

Texture2D

orbit_velocity_curve

float

orbit_velocity_max

0.0

float

orbit_velocity_min

0.0

bool

particle_flag_align_y

false

bool

particle_flag_damping_as_friction

false

bool

particle_flag_disable_z

false

bool

particle_flag_inherit_emitter_scale

false

bool

particle_flag_rotate_y

false

Texture2D

radial_accel_curve

float

radial_accel_max

0.0

float

radial_accel_min

0.0

Texture2D

radial_velocity_curve

float

radial_velocity_max

0.0

float

radial_velocity_min

0.0

Vector3

rotation_3d_max

Vector3

rotation_3d_min

Texture2D

rotation_velocity_3d_curve

Vector3

rotation_velocity_3d_max

Vector3

rotation_velocity_3d_min

Vector3

scale_3d_max

Vector3

scale_3d_min

Texture2D

scale_curve

float

scale_max

1.0

float

scale_min

1.0

Texture2D

scale_over_velocity_curve

float

scale_over_velocity_max

0.0

float

scale_over_velocity_min

0.0

float

spread

45.0

int

sub_emitter_amount_at_collision

int

sub_emitter_amount_at_end

int

sub_emitter_amount_at_start

float

sub_emitter_frequency

bool

sub_emitter_keep_velocity

false

SubEmitterMode

sub_emitter_mode

0

Texture2D

tangential_accel_curve

float

tangential_accel_max

0.0

float

tangential_accel_min

0.0

bool

turbulence_enabled

false

float

turbulence_influence_max

0.1

float

turbulence_influence_min

0.1

Texture2D

turbulence_influence_over_life

float

turbulence_initial_displacement_max

0.0

float

turbulence_initial_displacement_min

0.0

float

turbulence_noise_scale

9.0

Vector3

turbulence_noise_speed

Vector3(0, 0, 0)

float

turbulence_noise_speed_random

0.2

float

turbulence_noise_strength

1.0

bool

use_rotation_3d

false

bool

use_rotation_velocity_3d

false

bool

use_scale_3d

false

Texture2D

velocity_limit_curve

Vector3

velocity_pivot

Vector3(0, 0, 0)

Metodi

Vector2

get_param(param: Parameter) const

float

get_param_max(param: Parameter) const

float

get_param_min(param: Parameter) const

Texture2D

get_param_texture(param: Parameter) const

bool

get_particle_flag(particle_flag: ParticleFlags) const

void

set_param(param: Parameter, value: Vector2)

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)

Segnali

emission_shape_changed() 🔗

Emesso quando la forma di emissione di questo materiale viene modificata in qualsiasi modo. Ciò include modifiche a emission_shape, emission_shape_scale o emission_sphere_radius e qualsiasi altra proprietà che influenzi l'offset, le dimensioni, la scala o l'orientamento della forma di emissione.

Nota: Questo segnale viene emesso solo all'interno dell'editor per motivi di prestazioni.

Enumerazioni

enum Parameter: 🔗

Parameter PARAM_INITIAL_LINEAR_VELOCITY = 0

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà della velocità iniziale.

Parameter PARAM_ANGULAR_VELOCITY = 1

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà della velocità angolare.

Parameter PARAM_ORBIT_VELOCITY = 2

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà della velocità orbitale.

Parameter PARAM_LINEAR_ACCEL = 3

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà dell'accelerazione lineare.

Parameter PARAM_RADIAL_ACCEL = 4

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà dell'accelerazione radiale.

Parameter PARAM_TANGENTIAL_ACCEL = 5

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà dell'accelerazione tangenziale.

Parameter PARAM_DAMPING = 6

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà dello smorzamento.

Parameter PARAM_ANGLE = 7

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà dell'angolazione.

Parameter PARAM_SCALE = 8

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà della scala.

Parameter PARAM_HUE_VARIATION = 9

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà della variazione di tonalità.

Parameter PARAM_ANIM_SPEED = 10

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà della velocità di animazione.

Parameter PARAM_ANIM_OFFSET = 11

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà dell'offset di animazione.

Parameter PARAM_RADIAL_VELOCITY = 15

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà della velocità radiale.

Parameter PARAM_DIRECTIONAL_VELOCITY = 16

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà della velocità direzionale.

Parameter PARAM_SCALE_OVER_VELOCITY = 17

Usa con set_param_min(), set_param_max() e set_param_texture() per impostare le proprietà di scala rispetto alla velocità.

Parameter PARAM_MAX = 18

Rappresenta la dimensione dell'enumerazione Parameter.

Parameter PARAM_TURB_VEL_INFLUENCE = 13

Usa con set_param_min() e set_param_max() per impostare l'influenza minima e massima della turbolenza sulla velocità di ogni particella.

Parameter PARAM_TURB_INIT_DISPLACEMENT = 14

Usa con set_param_min() e set_param_max() per impostare lo spostamento minimo e massimo per la turbolenza nella posizione in cui sono generate le particelle.

Parameter PARAM_TURB_INFLUENCE_OVER_LIFE = 12

Utilizzare con set_param_texture() per impostare l'influenza della turbolenza nel corso della durata delle particelle.

enum ParticleFlags: 🔗

ParticleFlags PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY = 0

Da utilizzare con set_particle_flag() per impostare particle_flag_align_y.

ParticleFlags PARTICLE_FLAG_ROTATE_Y = 1

Da utilizzare con set_particle_flag() per impostare particle_flag_rotate_y.

ParticleFlags PARTICLE_FLAG_DISABLE_Z = 2

Da utilizzare con set_particle_flag() per impostare 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

Rappresenta la dimensione dell'enumerazione ParticleFlags.

enum EmissionShape: 🔗

EmissionShape EMISSION_SHAPE_POINT = 0

Tutte le particelle saranno emesse da un unico punto.

EmissionShape EMISSION_SHAPE_SPHERE = 1

Le particelle saranno emesse nel volume di una sfera.

EmissionShape EMISSION_SHAPE_SPHERE_SURFACE = 2

Le particelle saranno emesse sulla superfice di una sfera.

EmissionShape EMISSION_SHAPE_BOX = 3

Le particelle saranno emesse nel volume di una scatola.

EmissionShape EMISSION_SHAPE_POINTS = 4

Le particelle saranno emesse in una posizione determinata campionando un punto casuale su emission_point_texture. Il colore delle particelle sarà modulato da emission_color_texture.

EmissionShape EMISSION_SHAPE_DIRECTED_POINTS = 5

Le particelle saranno emesse in una posizione determinata campionando un punto casuale su emission_point_texture. La velocità e la rotazione delle particelle saranno impostate in base a emission_normal_texture. Il colore delle particelle sarà modulato da emission_color_texture.

EmissionShape EMISSION_SHAPE_RING = 6

Le particelle saranno emesse dentro un anello o un cilindro.

EmissionShape EMISSION_SHAPE_MAX = 7

Rappresenta la dimensione dell'enumerazione 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

Rappresenta la dimensione dell'enumerazione SubEmitterMode.

enum CollisionMode: 🔗

CollisionMode COLLISION_DISABLED = 0

Nessuna collisione per le particelle. Le particelle passeranno attraverso i nodi GPUParticlesCollision3D.

CollisionMode COLLISION_RIGID = 1

Collisione in stile RigidBody3D per le particelle che utilizzano nodi GPUParticlesCollision3D.

CollisionMode COLLISION_HIDE_ON_CONTACT = 2

Nascondi le particelle all'istante quando si scontrano con un nodo GPUParticlesCollision3D. Questo può essere combinato con un sottoemettitore che usa la modalità di collisione COLLISION_RIGID per "sostituire" la particella madre con il sottoemettitore all'impatto.

CollisionMode COLLISION_MAX = 3

Rappresenta la dimensione dell'enumerazione CollisionMode.

Descrizioni delle proprietà

Texture2D alpha_curve 🔗

The alpha value of each particle's color will be multiplied by this CurveTexture over its lifetime.

Note: alpha_curve multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo must be true. For a ShaderMaterial, ALPHA *= COLOR.a; must be inserted in the shader's fragment() function. Otherwise, alpha_curve will have no visible effect.

Texture2D angle_curve 🔗

La rotazione di ogni particella sarà animata lungo questa CurveTexture.

float angle_max = 0.0 🔗

Rotazione iniziale massima applicata a ciascuna particella, in gradi.

Applicata solo quando particle_flag_disable_z o particle_flag_rotate_y sono true o il BaseMaterial3D utilizzato per disegnare la particella utilizza BaseMaterial3D.BILLBOARD_PARTICLES.

float angle_min = 0.0 🔗

Equivalente minimo di angle_max.

Texture2D angular_velocity_curve 🔗

La velocità angolare di ogni particella (velocità di rotazione) varierà lungo questa CurveTexture nel corso della sua durata.

float angular_velocity_max = 0.0 🔗

Velocità angolare iniziale massima (velocità di rotazione) applicata a ogni particella in gradi al secondo.

Applicata solo quando particle_flag_disable_z o particle_flag_rotate_y sono true o il BaseMaterial3D utilizzato per disegnare la particella utilizza BaseMaterial3D.BILLBOARD_PARTICLES.

float angular_velocity_min = 0.0 🔗

Equivalente minimo di angular_velocity_max.

Texture2D anim_offset_curve 🔗

L'offset dell'animazione di ogni particella varierà lungo questa CurveTexture.

float anim_offset_max = 0.0 🔗

Offset massimo dell'animazione che corrisponde all'indice del fotogramma nella texture. 0 è il primo fotogramma, 1 è l'ultimo. Vedi CanvasItemMaterial.particles_animation.

float anim_offset_min = 0.0 🔗

Equivalente minimo di anim_offset_max.

Texture2D anim_speed_curve 🔗

La velocità dell'animazione di ogni particella varierà lungo questa CurveTexture.

float anim_speed_max = 0.0 🔗

Velocità massima d'animazione delle particelle. Una velocità d'animazione di 1 significa che le particelle faranno un ciclo di offset completo da 0 a 1 durante la loro durata, 2 significa 2 cicli ecc.

Con una velocità di animazione maggiore di 1, ricorda di abilitare la proprietà CanvasItemMaterial.particles_anim_loop se vuoi che l'animazione si ripeta.

float anim_speed_min = 0.0 🔗

Equivalente minimo di anim_speed_max.

bool attractor_interaction_enabled = true 🔗

  • void set_attractor_interaction_enabled(value: bool)

  • bool is_attractor_interaction_enabled()

Se true, l'interazione con gli attrattori di particelle è abilitata. In 3D, l'attrazione avviene solo all'interno dell'area definita dal nodo GPUParticles3D GPUParticles3D.visibility_aabb.

float collision_bounce 🔗

  • void set_collision_bounce(value: float)

  • float get_collision_bounce()

Il rimbalzo delle particelle. I valori variano da 0 (nessun rimbalzo) a 1 (rimbalzo totale). Efficace solo se collision_mode è COLLISION_RIGID.

float collision_friction 🔗

  • void set_collision_friction(value: float)

  • float get_collision_friction()

L'attrito delle particelle. I valori variano da 0 (senza attrito) a 1 (attrito massimo). Efficace solo se collision_mode è COLLISION_RIGID.

CollisionMode collision_mode = 0 🔗

La modalità di collisione delle particelle.

Nota: Le particelle 3D possono collidere solo con i nodi GPUParticlesCollision3D, non con i nodi PhysicsBody3D. Per far collidere le particelle con vari oggetti, puoi aggiungere i nodi GPUParticlesCollision3D come figli dei nodi PhysicsBody3D. In 3D, le collisioni si verificano solo all'interno dell'area definita dal nodo GPUParticles3D GPUParticles3D.visibility_aabb.

Nota: Le particelle 2D possono collidere solo con i nodi LightOccluder2D, non con i nodi PhysicsBody2D.

bool collision_use_scale = false 🔗

  • void set_collision_use_scale(value: bool)

  • bool is_collision_using_scale()

Se true, GPUParticles3D.collision_base_size viene moltiplicato per la scala effettiva della particella (vedi scale_min, scale_max, scale_curve e scale_over_velocity_curve).

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

Il colore iniziale di ogni particella. Se la texture di GPUParticles2D è definita, sarà moltiplicata per questo colore.

Nota: color moltiplica i colori dei vertici della mesh di particelle. Per avere un effetto visibile su un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo deve essere true. Per uno ShaderMaterial, ALBEDO *= COLOR.rgb; deve essere inserito nella funzione fragment() dello shader. Altrimenti, color non avrà alcun effetto visibile.

Texture2D color_initial_ramp 🔗

Il colore iniziale di ogni particella varierà lungo questa GradientTexture1D (moltiplicato per color).

Nota: color moltiplica i colori dei vertici della mesh di particelle. Per avere un effetto visibile su un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo deve essere true. Per uno ShaderMaterial, ALBEDO *= COLOR.rgb; deve essere inserito nella funzione fragment() dello shader. Altrimenti, color non avrà alcun effetto visibile.

Texture2D color_ramp 🔗

Il colore di ogni particella varierà lungo questa GradientTexture1D per tutta la sua durata (moltiplicato per color).

Nota: color moltiplica i colori dei vertici della mesh di particelle. Per avere un effetto visibile su un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo deve essere true. Per uno ShaderMaterial, ALBEDO *= COLOR.rgb; deve essere inserito nella funzione fragment() dello shader. Altrimenti, color non avrà alcun effetto visibile.

Texture2D damping_curve 🔗

Lo smorzamento varierà lungo questa CurveTexture.

float damping_max = 0.0 🔗

La frequenza massima a cui le particelle perdono velocità. Ad esempio, il valore di 100 significa che la particella passerà da una velocità di 100 a una velocità di 0 in 1 secondo.

float damping_min = 0.0 🔗

Equivalente minimo di damping_max.

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

Vettore unitario che specifica la direzione di emissione delle particelle.

Texture2D directional_velocity_curve 🔗

Una curva che specifica la velocità lungo ciascuno degli assi del sistema di particelle nel corso della sua durata.

Nota: Le velocità animate non saranno influenzate dallo smorzamento, utilizza invece velocity_limit_curve.

float directional_velocity_max 🔗

Valore massimo della velocità direzionale, che è moltiplicato per directional_velocity_curve.

Nota: Le velocità animate non saranno influenzate dallo smorzamento, utilizza invece velocity_limit_curve.

float directional_velocity_min 🔗

Valore minimo della velocità direzionale, che è moltiplicato per directional_velocity_curve.

Nota: Le velocità animate non saranno influenzate dallo smorzamento, utilizza invece velocity_limit_curve.

Vector3 emission_box_extents 🔗

  • void set_emission_box_extents(value: Vector3)

  • Vector3 get_emission_box_extents()

Le estensioni del box se emission_shape è impostato su EMISSION_SHAPE_BOX.

Nota: emission_box_extents inizia dal punto centrale e applica i valori X, Y e Z in entrambe le direzioni. La dimensione è il doppio dell'area delle estensioni.

Texture2D emission_color_texture 🔗

  • void set_emission_color_texture(value: Texture2D)

  • Texture2D get_emission_color_texture()

Il colore delle particelle sarà modulato dal colore determinato dal campionamento di questa texture nello stesso punto di emission_point_texture.

Nota: emission_color_texture moltiplica i colori dei vertici della mesh delle particelle. Per avere un effetto visibile su un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo deve essere true. Per uno ShaderMaterial, ALBEDO *= COLOR.rgb; deve essere inserito nella funzione fragment() dello shader. Altrimenti, emission_color_texture non avrà alcun effetto visibile.

Texture2D emission_curve 🔗

Il colore di ogni particella sarà moltiplicato per questa CurveTexture nel corso della sua durata.

Nota: emission_curve moltiplica i colori dei vertici della mesh di particelle. Per avere un effetto visibile su un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo deve essere true. Per uno ShaderMaterial, ALBEDO *= COLOR.rgb; deve essere inserito nella funzione fragment() dello shader. Altrimenti, color non avrà alcun effetto visibile.

Texture2D emission_normal_texture 🔗

  • void set_emission_normal_texture(value: Texture2D)

  • Texture2D get_emission_normal_texture()

La velocità e la rotazione delle particelle saranno impostate campionando questa texture nello stesso punto di emission_point_texture. Utilizzato solo in EMISSION_SHAPE_DIRECTED_POINTS. Può essere creato automaticamente da mesh o da nodo selezionando "Crea punti di emissione per mesh/nodo" sotto lo strumento "Particelle" nella barra degli strumenti.

int emission_point_count 🔗

  • void set_emission_point_count(value: int)

  • int get_emission_point_count()

Numero di punti di emissione se emission_shape è impostato su EMISSION_SHAPE_POINTS o EMISSION_SHAPE_DIRECTED_POINTS.

Texture2D emission_point_texture 🔗

  • void set_emission_point_texture(value: Texture2D)

  • Texture2D get_emission_point_texture()

Le particelle saranno emesse in posizioni determinate dal campionamento di questa texture in una posizione a caso. Utilizzato con EMISSION_SHAPE_POINTS e EMISSION_SHAPE_DIRECTED_POINTS. Può essere creato automaticamente da mesh o da nodo selezionando "Crea punti di emissione per mesh/nodo" sotto lo strumento "Particelle" nella barra degli strumenti.

Vector3 emission_ring_axis 🔗

  • void set_emission_ring_axis(value: Vector3)

  • Vector3 get_emission_ring_axis()

L'asse dell'anello per l'emettitore EMISSION_SHAPE_RING.

float emission_ring_cone_angle 🔗

  • void set_emission_ring_cone_angle(value: float)

  • float get_emission_ring_cone_angle()

L'angolo del cono quando si usa l'emettitore EMISSION_SHAPE_RING. L'angolo predefinito di 90 gradi produce un anello, mentre un angolo di 0 gradi produce un cono. I valori intermedi produrranno un anello in cui un'estremità è più grande dell'altra.

Nota: A seconda di emission_ring_height, l'angolo potrebbe essere limitato se si raggiunge l'estremità dell'anello per formare un cono perfetto.

float emission_ring_height 🔗

  • void set_emission_ring_height(value: float)

  • float get_emission_ring_height()

L'altezza dell'anello per l'emettitore EMISSION_SHAPE_RING.

float emission_ring_inner_radius 🔗

  • void set_emission_ring_inner_radius(value: float)

  • float get_emission_ring_inner_radius()

Il raggio interno dell'anello per l'emettitore EMISSION_SHAPE_RING.

float emission_ring_radius 🔗

  • void set_emission_ring_radius(value: float)

  • float get_emission_ring_radius()

Il raggio dell'anello per l'emettitore EMISSION_SHAPE_RING.

EmissionShape emission_shape = 0 🔗

Le particelle saranno emesse dentro questa regione.

Vector3 emission_shape_offset = Vector3(0, 0, 0) 🔗

  • void set_emission_shape_offset(value: Vector3)

  • Vector3 get_emission_shape_offset()

L'offset per emission_shape, nello spazio locale.

Vector3 emission_shape_scale = Vector3(1, 1, 1) 🔗

  • void set_emission_shape_scale(value: Vector3)

  • Vector3 get_emission_shape_scale()

La scala per emission_shape, nello spazio locale.

float emission_sphere_radius 🔗

  • void set_emission_sphere_radius(value: float)

  • float get_emission_sphere_radius()

Il raggio della sfera se emission_shape è impostato su EMISSION_SHAPE_SPHERE.

float flatness = 0.0 🔗

  • void set_flatness(value: float)

  • float get_flatness()

Quantità di distribuzione (spread) lungo l'asse Y.

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

Gravità applicata a ogni particella.

Texture2D hue_variation_curve 🔗

La tonalità di ogni particella varierà lungo questa CurveTexture.

float hue_variation_max = 0.0 🔗

Massima variazione iniziale della tonalità applicata a ogni particella. Ciò sposterà la tonalità del colore della particella.

float hue_variation_min = 0.0 🔗

Equivalente minimo di hue_variation_max.

float inherit_velocity_ratio = 0.0 🔗

  • void set_inherit_velocity_ratio(value: float)

  • float get_inherit_velocity_ratio()

Percentuale della velocità del rispettivo GPUParticles2D o GPUParticles3D ereditata da ogni particella quando sono generate.

float initial_velocity_max = 0.0 🔗

Massima ampiezza della velocità iniziale per ogni particella. La direzione deriva da direction e spread.

float initial_velocity_min = 0.0 🔗

Equivalente minimo di initial_velocity_max.

float lifetime_randomness = 0.0 🔗

  • void set_lifetime_randomness(value: float)

  • float get_lifetime_randomness()

Rapporto di casualità della durata della particella. L'equazione per la durata di una particella è durata* (1.0 - randf() * casualità_durata). Ad esempio, un lifetime_randomness di 0.4 ridimensiona la durata tra 0.6 e 1.0 del suo valore originale.

Texture2D linear_accel_curve 🔗

L'accelerazione lineare di ogni particella varierà lungo questa CurveTexture.

float linear_accel_max = 0.0 🔗

Accelerazione lineare massima applicata a ciascuna particella nella direzione del movimento.

float linear_accel_min = 0.0 🔗

Equivalente minimo di linear_accel_max.

Texture2D orbit_velocity_curve 🔗

La velocità orbitale di ogni particella varierà lungo questa CurveTexture.

Nota: Per la velocità orbitale 3D, usa una CurveXYZTexture.

Nota: Le velocità animate non saranno influenzate dallo smorzamento, usa invece velocity_limit_curve.

float orbit_velocity_max = 0.0 🔗

Velocità orbitale massima applicata a ogni particella. Fa circolare le particelle attorno all'origine. Specificato in numero di rotazioni complete attorno all'origine al secondo.

Nota: Le velocità animate non saranno influenzate dallo smorzamento, utilizzare invece velocity_limit_curve.

float orbit_velocity_min = 0.0 🔗

Equivalente minimo di orbit_velocity_max.

Nota: Le velocità animate non saranno influenzate dallo smorzamento, utilizza velocity_limit_curve invece.

bool particle_flag_align_y = false 🔗

Allinea l'asse Y della particella con la direzione della sua velocità.

bool particle_flag_damping_as_friction = false 🔗

Modifica il comportamento delle proprietà di smorzamento da una decelerazione lineare a una decelerazione basata su una percentuale della velocità.

bool particle_flag_disable_z = false 🔗

Se true, le particelle non si muoveranno sull'asse z.

bool particle_flag_inherit_emitter_scale = false 🔗

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 🔗

Se true, le particelle ruotano attorno all'asse Y di angle_min.

Texture2D radial_accel_curve 🔗

L'accelerazione radiale di ogni particella varierà lungo questa CurveTexture.

float radial_accel_max = 0.0 🔗

Accelerazione radiale massima applicata a ciascuna particella. Fa accelerare la particella, allontanandola dall'origine o avvicinandola se il valore è negativo.

float radial_accel_min = 0.0 🔗

Equivalente minimo di radial_accel_max.

Texture2D radial_velocity_curve 🔗

Una CurveTexture che definisce la velocità nel corso della vita della particella in allontanamento (o verso) da velocity_pivot.

Nota: Le velocità animate non saranno influenzate dallo smorzamento, utilizza invece velocity_limit_curve.

float radial_velocity_max = 0.0 🔗

Velocità radiale massima applicata a ogni particella. Fa allontanare le particelle da velocity_pivot, o avvicinare ad esso se la velocità è negativa.

Nota: Le velocità animate non saranno influenzate dallo smorzamento, utilizza invece velocity_limit_curve.

float radial_velocity_min = 0.0 🔗

Velocità radiale minima applicata a ogni particella. Fa allontanare le particelle da velocity_pivot, o avvicinare ad esso se la velocità è negativa.

Nota: Le velocità animate non saranno influenzate dallo smorzamento, utilizza invece velocity_limit_curve.

Vector3 rotation_3d_max 🔗

  • void set_rotation_3d_max(value: Vector3)

  • Vector3 get_rotation_3d_max()

The maximum 3D orientation, in degrees. Works only in 3D and if use_rotation_3d is enabled.

Vector3 rotation_3d_min 🔗

  • void set_rotation_3d_min(value: Vector3)

  • Vector3 get_rotation_3d_min()

The minimum 3D orientation, in degrees. Works only in 3D and if use_rotation_3d is enabled.

Texture2D rotation_velocity_3d_curve 🔗

  • void set_rotation_velocity_3d_curve(value: Texture2D)

  • Texture2D get_rotation_velocity_3d_curve()

Rotation velocity curve over lifetime, per-axis. Enable use_rotation_velocity_3d to use this.

Vector3 rotation_velocity_3d_max 🔗

  • void set_rotation_velocity_3d_max(value: Vector3)

  • Vector3 get_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 🔗

  • void set_rotation_velocity_3d_min(value: Vector3)

  • Vector3 get_rotation_velocity_3d_min()

Minimum 3D rotation velocity on the particle's local axis. Enable use_rotation_velocity_3d to use this.

Vector3 scale_3d_max 🔗

The maximum value of the random scale vector for each particle.

Works only if use_scale_3d is enabled.

Vector3 scale_3d_min 🔗

The minimum value of the random scale vector for each particle.

Works only if use_scale_3d is enabled.

Texture2D scale_curve 🔗

La scala di ogni particella varierà lungo questa CurveTexture nel corso della sua durata. Se invece viene fornita una CurveXYZTexture, la scala sarà separata per asse.

float scale_max = 1.0 🔗

Scala iniziale massima applicata a ciascuna particella.

float scale_min = 1.0 🔗

Equivalente minimo di scale_max.

Texture2D scale_over_velocity_curve 🔗

Una CurveTexture o una CurveXYZTexture che ridimensiona ogni particella in base alla sua velocità.

float scale_over_velocity_max = 0.0 🔗

Riferimento massimo al valore di velocità per scale_over_velocity_curve.

scale_over_velocity_curve sarà interpolato tra scale_over_velocity_min e scale_over_velocity_max.

float scale_over_velocity_min = 0.0 🔗

Riferimento minimo al valore di velocità per scale_over_velocity_curve.

scale_over_velocity_curve sarà interpolato tra scale_over_velocity_min e scale_over_velocity_max.

float spread = 45.0 🔗

  • void set_spread(value: float)

  • float get_spread()

La direzione iniziale di ciascuna particella varia da +spread a -spread (in gradi).

int sub_emitter_amount_at_collision 🔗

  • void set_sub_emitter_amount_at_collision(value: int)

  • int get_sub_emitter_amount_at_collision()

La quantità di particelle da generare dal nodo sottoemettitore quando si verifica una collisione. Se combinato con COLLISION_HIDE_ON_CONTACT sul materiale delle particelle principali, può essere utilizzato per ottenere effetti come gocce di pioggia che colpiscono il terreno.

Nota: Questo valore non dovrebbe superare GPUParticles2D.amount o GPUParticles3D.amount definiti sul nodo sottoemettitore (non il nodo principale), in relazione alla durata delle particelle del sottoemettitore. Se il numero di particelle viene superato, nessuna nuova particella verrà generata dal sottoemettitore finché non avranno terminato abbastanza particelle.

int sub_emitter_amount_at_end 🔗

  • void set_sub_emitter_amount_at_end(value: int)

  • int get_sub_emitter_amount_at_end()

Quantità di particelle da generare dal nodo sottoemettitore quando la particella finisce.

Nota: Questo valore non dovrebbe superare GPUParticles2D.amount o GPUParticles3D.amount definiti sul nodo sottoemettitore (non il nodo principale), in relazione alla durata delle particelle del sottoemettitore. Se il numero di particelle viene superato, nessuna nuova particella verrà generata dal sottoemettitore finché non avranno terminato abbastanza particelle.

int sub_emitter_amount_at_start 🔗

  • void set_sub_emitter_amount_at_start(value: int)

  • int get_sub_emitter_amount_at_start()

La quantità di particelle da generare dal nodo sottoemettitore quando la particella viene generata.

Nota: Questo valore non dovrebbe superare GPUParticles2D.amount o GPUParticles3D.amount definiti sul nodo sottoemettitore (non il nodo principale), in relazione alla durata delle particelle del sottoemettitore. Se il numero di particelle viene superato, nessuna nuova particella verrà generata dal sottoemettitore finché non avranno terminato abbastanza particelle.

float sub_emitter_frequency 🔗

  • void set_sub_emitter_frequency(value: float)

  • float get_sub_emitter_frequency()

La frequenza con cui le particelle devono essere emesse dal nodo sottoemettitore. Una particella verrà generata ogni sub_emitter_frequency secondi.

Nota: Questo valore non dovrebbe superare GPUParticles2D.amount o GPUParticles3D.amount definiti sul nodo sottoemettitore (non il nodo principale), in relazione alla durata delle particelle del sottoemettitore. Se il numero di particelle viene superato, nessuna nuova particella verrà generata dal sottoemettitore finché non avranno terminato abbastanza particelle.

bool sub_emitter_keep_velocity = false 🔗

  • void set_sub_emitter_keep_velocity(value: bool)

  • bool get_sub_emitter_keep_velocity()

Se true, il sottoemettitore eredita la velocità della particella madre quando viene generata.

SubEmitterMode sub_emitter_mode = 0 🔗

La modalità del sottoemettitore di particelle (vedi GPUParticles2D.sub_emitter e GPUParticles3D.sub_emitter).

Texture2D tangential_accel_curve 🔗

L'accelerazione tangenziale di ogni particella varierà lungo questa CurveTexture.

float tangential_accel_max = 0.0 🔗

Accelerazione tangenziale massima applicata a ciascuna particella. L'accelerazione tangenziale è perpendicolare alla velocità della particella, dandogli un movimento vorticoso.

float tangential_accel_min = 0.0 🔗

Equivalente minimo di tangential_accel_max.

bool turbulence_enabled = false 🔗

  • void set_turbulence_enabled(value: bool)

  • bool get_turbulence_enabled()

Se true, abilita la turbolenza per il sistema di particelle. La turbolenza può essere utilizzata per variare il movimento delle particelle in base alla loro posizione (in base a un modello di noise 3D). In 3D, GPUParticlesAttractorVectorField3D con NoiseTexture3D può essere utilizzato come alternativa alla turbolenza che funziona nello spazio mondiale e con più sistemi di particelle che reagiscono allo stesso modo.

Nota: L'abilitazione della turbolenza ha un costo elevato in termini di prestazioni sulla GPU. Abilita la turbolenza solo su pochi sistemi di particelle alla volta e considera di disabilitarla per le piattaforme mobili/web.

float turbulence_influence_max = 0.1 🔗

Influenza massima della turbolenza su ogni particella.

La quantità effettiva di influenza della turbolenza su ogni particella viene calcolata come un valore casuale tra turbulence_influence_min e turbulence_influence_max e moltiplicata per la quantità di influenza della turbolenza da turbulence_influence_over_life.

float turbulence_influence_min = 0.1 🔗

Influenza minima della turbolenza su ogni particella.

La quantità effettiva di influenza della turbolenza su ogni particella viene calcolata come un valore casuale tra turbulence_influence_min e turbulence_influence_max e moltiplicata per la quantità di influenza della turbolenza da turbulence_influence_over_life.

Texture2D turbulence_influence_over_life 🔗

La quantità di turbolenza di ogni particella sarà influenzata lungo questa CurveTexture nel corso della sua durata.

float turbulence_initial_displacement_max = 0.0 🔗

Spostamento massimo della posizione in cui ogni particella viene generata, per la turbolenza.

La quantità effettiva di spostamento sarà un fattore della turbolenza sottostante moltiplicato per un valore casuale tra turbulence_initial_displacement_min e turbulence_initial_displacement_max.

float turbulence_initial_displacement_min = 0.0 🔗

Spostamento minimo della posizione in cui ogni particella viene generata, per la turbolenza.

La quantità effettiva di spostamento sarà un fattore della turbolenza sottostante moltiplicato per un valore casuale tra turbulence_initial_displacement_min e turbulence_initial_displacement_max.

float turbulence_noise_scale = 9.0 🔗

  • void set_turbulence_noise_scale(value: float)

  • float get_turbulence_noise_scale()

Questo valore controlla la scala/frequenza complessiva del motivo del noise di turbolenza.

Una piccola scala produrrà caratteristiche più piccole con maggiori dettagli, mentre una scala alta produrrà un noise più uniforme con caratteristiche più grandi.

Vector3 turbulence_noise_speed = Vector3(0, 0, 0) 🔗

  • void set_turbulence_noise_speed(value: Vector3)

  • Vector3 get_turbulence_noise_speed()

Una velocità di scorrimento per il campo di turbolenza. Ciò stabilisce una tendenza direzionale affinché il motivo si muova nel tempo.

Il valore predefinito di Vector3(0, 0, 0) disattiva lo scorrimento.

float turbulence_noise_speed_random = 0.2 🔗

  • void set_turbulence_noise_speed_random(value: float)

  • float get_turbulence_noise_speed_random()

Il tasso di variazione sul posto del campo di turbolenza. Definisce la rapidità con cui il motivo del noise varia nel tempo.

Un valore di 0,0 risulterà in un motivo fisso.

float turbulence_noise_strength = 1.0 🔗

  • void set_turbulence_noise_strength(value: float)

  • float get_turbulence_noise_strength()

L'intensità del noise di turbolenza. Aumentandolo si otterrà un motivo di flusso più forte e contrastante.

bool use_rotation_3d = false 🔗

  • void set_use_rotation_3d(value: bool)

  • bool is_using_rotation_3d()

Enable the usage of rotation_3d_min and rotation_3d_max.

bool use_rotation_velocity_3d = false 🔗

  • void set_using_rotation_velocity_3d(value: bool)

  • bool is_using_rotation_velocity_3d()

Enable 3D rotation velocity.

bool use_scale_3d = false 🔗

  • void set_use_scale_3d(value: bool)

  • bool is_using_scale_3d()

Enable the usage of scale_3d_min and scale_3d_max.

Texture2D velocity_limit_curve 🔗

Una CurveTexture che definisce la velocità massima di una particella durante il suo ciclo di vita.

Vector3 velocity_pivot = Vector3(0, 0, 0) 🔗

  • void set_velocity_pivot(value: Vector3)

  • Vector3 get_velocity_pivot()

Un punto di rotazione utilizzato per calcolare la velocità radiale e orbitale delle particelle.

Descrizioni dei metodi

Vector2 get_param(param: Parameter) const 🔗

Restituisce i valori minimo e massimo del parametro param, sotto forma di vettore.

Il componente x del vettore restituito corrisponde al minimo e il componente y corrisponde al massimo.

float get_param_max(param: Parameter) const 🔗

Restituisce il valore massimo dell'intervallo per il parametro specificato.

float get_param_min(param: Parameter) const 🔗

Restituisce il valore minimo dell'intervallo per il parametro specificato.

Texture2D get_param_texture(param: Parameter) const 🔗

Restituisce la Texture2D utilizzata dal parametro specificato.

bool get_particle_flag(particle_flag: ParticleFlags) const 🔗

Restituisce true se il flag di particelle specificato è abilitato.

void set_param(param: Parameter, value: Vector2) 🔗

Imposta i valori minimo e massimo del parametro param.

Il componente x del vettore specificato corrisponde al minimo e il componente y corrisponde al massimo.

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

Imposta l'intervallo di valore massimo per il parametro indicato.

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

Imposta l'intervallo di valore minimo per il parametro indicato.

void set_param_texture(param: Parameter, texture: Texture2D) 🔗

Imposta la Texture2D per il parametro specificato (Parameter).

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

Imposta il flag di particelle particle_flag su enable.