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

Eredita: GeometryInstance3D < VisualInstance3D < Node3D < Node < Object

Un emettitore di particelle 3D basato su CPU.

Descrizione

Nodo di particelle 3D basato su CPU utilizzato per creare una varietà di sistemi ed effetti di particelle.

Vedi anche GPUParticles3D, che fornisce la stessa funzionalità con accelerazione hardware, ma potrebbe non funzionare su dispositivi più vecchi.

Tutorial

Proprietà

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)

Metodi

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)

Segnali

finished() 🔗

Emesso quando tutte le particelle attive hanno terminato l'elaborazione. Quando one_shot è disabilitato, le particelle saranno elaborate in modo continuo, quindi non verrà mai emesso.

Enumerazioni

enum DrawOrder: 🔗

DrawOrder DRAW_ORDER_INDEX = 0

Le particelle sono disegnate nell'ordine in cui sono emesse.

DrawOrder DRAW_ORDER_LIFETIME = 1

Le particelle sono disegnate nell'ordine di tempo di vita residuo. In altre parole, la particella con il tempo di vita più alto è disegnata davanti.

DrawOrder DRAW_ORDER_VIEW_DEPTH = 2

Le particelle sono disegnate in ordine di profondità.

enum Parameter: 🔗

Parameter PARAM_INITIAL_LINEAR_VELOCITY = 0

Da utilizzare con set_param_min(), set_param_max(), e set_param_curve() per impostare le proprietà della velocità iniziale.

Parameter PARAM_ANGULAR_VELOCITY = 1

Da utilizzare con set_param_min(), set_param_max(), e set_param_curve() per impostare le proprietà della velocità angolare.

Parameter PARAM_ORBIT_VELOCITY = 2

Da utilizzare con set_param_min(), set_param_max(), e set_param_curve() per impostare le proprietà della velocità orbitale.

Parameter PARAM_LINEAR_ACCEL = 3

Da utilizzare con set_param_min(), set_param_max(), e set_param_curve() per impostare le proprietà dell'accelerazione lineare.

Parameter PARAM_RADIAL_ACCEL = 4

Da utilizzare con set_param_min(), set_param_max(), e set_param_curve() per impostare le proprietà dell'accelerazione radiale.

Parameter PARAM_TANGENTIAL_ACCEL = 5

Da utilizzare con set_param_min(), set_param_max(), e set_param_curve() per impostare le proprietà dell'accelerazione tangenziale.

Parameter PARAM_DAMPING = 6

Da utilizzare con set_param_min(), set_param_max(), e set_param_curve() per impostare le proprietà dello smorzamento.

Parameter PARAM_ANGLE = 7

Da utilizzare con set_param_min(), set_param_max(), e set_param_curve() per impostare le proprietà dell'angolo.

Parameter PARAM_SCALE = 8

Da utilizzare con set_param_min(), set_param_max(), e set_param_curve() per impostare le proprietà della scala.

Parameter PARAM_HUE_VARIATION = 9

Da utilizzare con set_param_min(), set_param_max(), e set_param_curve() per impostare le proprietà della variazione di tonalità.

Parameter PARAM_ANIM_SPEED = 10

Da utilizzare con set_param_min(), set_param_max(), e set_param_curve() per impostare le proprietà della velocità di animazione.

Parameter PARAM_ANIM_OFFSET = 11

Da utilizzare con set_param_min(), set_param_max(), e set_param_curve() per impostare le proprietà dell'offset di animazione.

Parameter PARAM_MAX = 12

Rappresenta la dimensione dell'enumerazione Parameter.

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_MAX = 3

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 scelta a caso tra i punti emission_points. Il colore delle particelle sarà modulato per emission_colors.

EmissionShape EMISSION_SHAPE_DIRECTED_POINTS = 5

Le particelle saranno emesse in una posizione scelta a caso tra i punti emission_points. La velocità e la rotazione delle particelle saranno impostate in base a emission_normals. Il colore delle particelle sarà modulato per emission_colors.

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.

Descrizioni delle proprietà

int amount = 8 🔗

  • void set_amount(value: int)

  • int get_amount()

Numero di particelle emesse in un singolo ciclo di emissione.

Curve angle_curve 🔗

La rotazione di ogni particella sarà animata lungo questa Curve. Dovrebbe essere una Curve unitaria.

float angle_max = 0.0 🔗

Angolo massimo.

float angle_min = 0.0 🔗

Angolo minimo.

Curve angular_velocity_curve 🔗

La velocità angolare di ogni particella (velocità di rotazione) varierà lungo questa Curve per tutta la sua durata. Dovrebbe essere una Curve unitaria.

float angular_velocity_max = 0.0 🔗

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

float angular_velocity_min = 0.0 🔗

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

Curve anim_offset_curve 🔗

L'offset dell'animazione di ogni particella varierà lungo questa Curve. Dovrebbe essere una Curve unitaria.

float anim_offset_max = 0.0 🔗

Offset massimo dell'animazione.

float anim_offset_min = 0.0 🔗

Offset minimo dell'animazione.

Curve anim_speed_curve 🔗

La velocità dell'animazione di ogni particella varierà lungo questa Curve. Dovrebbe essere una Curve unitaria.

float anim_speed_max = 0.0 🔗

Velocità di animazione delle particelle massima.

float anim_speed_min = 0.0 🔗

Velocità di animazione delle particelle minima.

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

Colore iniziale di ogni particella.

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.

Gradient color_initial_ramp 🔗

  • void set_color_initial_ramp(value: Gradient)

  • Gradient get_color_initial_ramp()

Il colore iniziale di ogni particella varierà lungo questo Gradient (moltiplicato per color).

Nota: color_initial_ramp 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_initial_ramp non avrà alcun effetto visibile.

Gradient color_ramp 🔗

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

Nota: color_ramp 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_ramp non avrà alcun effetto visibile.

Curve damping_curve 🔗

Lo smorzamento varierà lungo questa Curve. Dovrebbe essere una Curve unitaria.

float damping_max = 0.0 🔗

Smorzamento massimo.

float damping_min = 0.0 🔗

Smorzamento minimo.

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

Vettore unitario che specifica la direzione di emissione delle particelle.

DrawOrder draw_order = 0 🔗

Ordine di disegno delle particelle.

Vector3 emission_box_extents 🔗

  • void set_emission_box_extents(value: Vector3)

  • Vector3 get_emission_box_extents()

Estensioni del rettangolo se emission_shape è impostato su EMISSION_SHAPE_BOX.

PackedColorArray emission_colors = PackedColorArray() 🔗

Imposta i Color con cui modulare le particelle quando si utilizza EMISSION_SHAPE_POINTS o EMISSION_SHAPE_DIRECTED_POINTS.

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.

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 🔗

Imposta la direzione in cui saranno emesse le particelle quando si utilizza 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.

PackedVector3Array emission_points 🔗

Imposta le posizioni iniziali per generare le particelle quando si utilizza EMISSION_SHAPE_POINTS o 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'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.

float emission_sphere_radius 🔗

  • void set_emission_sphere_radius(value: float)

  • float get_emission_sphere_radius()

Il raggio della sfera se EmissionShape è impostato su EMISSION_SHAPE_SPHERE.

bool emitting = true 🔗

  • void set_emitting(value: bool)

  • bool is_emitting()

Se true, le particelle sono emesse. emitting può essere utilizzato per avviare e interrompere l'emissione di particelle. Tuttavia, se one_shot è true, l'impostazione di emitting su true non riavvierà il ciclo di emissione finché tutte le particelle attive non avranno completato l'elaborazione. Puoi utilizzare il segnale finished per essere avvisato una volta che tutte le particelle attive avranno completato l'elaborazione.

float explosiveness = 0.0 🔗

  • void set_explosiveness_ratio(value: float)

  • float get_explosiveness_ratio()

Quanto rapidamente sono emesse le particelle in un ciclo di emissione. Se maggiore di 0, ci sarà un distacco nelle emissioni prima che inizi il ciclo successivo.

int fixed_fps = 0 🔗

  • void set_fixed_fps(value: int)

  • int get_fixed_fps()

La frequenza dei fotogrammi del sistema di particelle è fissato a un valore. Ad esempio, cambiando il valore a 2, le particelle saranno renderizzate a 2 fotogrammi al secondo. Nota che questo non rallenta la simulazione del sistema di particelle stesso.

float flatness = 0.0 🔗

  • void set_flatness(value: float)

  • float get_flatness()

Quantità di propagazione (spread) nel piano Y/Z. Un valore di 1 limita le particelle al piano X/Z.

bool fract_delta = true 🔗

  • void set_fractional_delta(value: bool)

  • bool get_fractional_delta()

Se true, utilizza un calcolo di delta frazionario che consente una visualizzazione più fluida delle particelle.

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

Gravità applicata a ogni particella.

Curve hue_variation_curve 🔗

La tonalità di ogni particella varierà lungo questa Curve. Dovrebbe essere una Curve unitaria.

float hue_variation_max = 0.0 🔗

Variazione di tonalità massima.

float hue_variation_min = 0.0 🔗

Variazione di tonalità minima.

float initial_velocity_max = 0.0 🔗

Valore della velocità iniziale massimo.

float initial_velocity_min = 0.0 🔗

Valore della velocità iniziale minimo.

float lifetime = 1.0 🔗

  • void set_lifetime(value: float)

  • float get_lifetime()

Quantità di tempo in cui ogni particella esisterà.

float lifetime_randomness = 0.0 🔗

  • void set_lifetime_randomness(value: float)

  • float get_lifetime_randomness()

Rapporto di casualità della durata di vita delle particelle.

Curve linear_accel_curve 🔗

L'accelerazione lineare di ogni particella varierà lungo questa Curve. Dovrebbe essere una Curve unitaria.

float linear_accel_max = 0.0 🔗

Accelerazione lineare massima.

float linear_accel_min = 0.0 🔗

Accelerazione lineare minima.

bool local_coords = false 🔗

  • void set_use_local_coordinates(value: bool)

  • bool get_use_local_coordinates()

Se true, le particelle usano lo spazio di coordinate del nodo genitore (noto come coordinate locali). Ciò farà sì che le particelle si muovano e ruotino lungo il nodo CPUParticles3D (e i suoi genitori) quando viene spostato o ruotato. Se false, le particelle usano coordinate globali; non si muoveranno o ruoteranno lungo il nodo CPUParticles3D (e i suoi genitori) quando viene spostato o ruotato.

Mesh mesh 🔗

  • void set_mesh(value: Mesh)

  • Mesh get_mesh()

La Mesh utilizzata per ogni particella. Se null, le particelle saranno sfere.

bool one_shot = false 🔗

  • void set_one_shot(value: bool)

  • bool get_one_shot()

Se true, un solo ciclo di emissione sarà prodotto. Se impostato su true durante un ciclo, l'emissione si interromperà alla fine del ciclo.

Curve orbit_velocity_curve 🔗

La velocità orbitale di ciascuna particella varierà lungo questa Curve. Dovrebbe essere una Curve unitaria.

float orbit_velocity_max 🔗

Velocità orbitale massima.

float orbit_velocity_min 🔗

Velocità orbitale minima.

bool particle_flag_align_y = false 🔗

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

bool particle_flag_disable_z = false 🔗

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

bool particle_flag_rotate_y = false 🔗

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

float preprocess = 0.0 🔗

  • void set_pre_process_time(value: float)

  • float get_pre_process_time()

Il sistema di particelle si avvia come se avesse già cominciato questo numero di secondi fa.

Curve radial_accel_curve 🔗

L'accelerazione radiale di ogni particella varierà lungo questa Curve. Dovrebbe essere una Curve unitaria.

float radial_accel_max = 0.0 🔗

Accelerazione radiale massima.

float radial_accel_min = 0.0 🔗

Accelerazione radiale minima.

float randomness = 0.0 🔗

  • void set_randomness_ratio(value: float)

  • float get_randomness_ratio()

Rapporto di casualità del tempo di vita dell'emissione.

Curve scale_amount_curve 🔗

La scala di ciascuna particella varierà lungo questa Curve. Dovrebbe essere una Curve unitaria.

float scale_amount_max = 1.0 🔗

Scala massima.

float scale_amount_min = 1.0 🔗

Scala minima.

Curve scale_curve_x 🔗

  • void set_scale_curve_x(value: Curve)

  • Curve get_scale_curve_x()

Curva della scala sul tempo di vita, lungo l'asse x.

Curve scale_curve_y 🔗

  • void set_scale_curve_y(value: Curve)

  • Curve get_scale_curve_y()

Curva della scala sul tempo di vita, lungo l'asse y.

Curve scale_curve_z 🔗

  • void set_scale_curve_z(value: Curve)

  • Curve get_scale_curve_z()

Curva della scala sul tempo di vita, lungo l'asse z.

int seed = 0 🔗

  • void set_seed(value: int)

  • int get_seed()

Imposta il seed casuale utilizzato dal sistema di particelle. Efficace solo se use_fixed_seed è true.

float speed_scale = 1.0 🔗

  • void set_speed_scale(value: float)

  • float get_speed_scale()

Rapporto della velocità di esecuzione del sistema di particelle. Un valore di 0 può essere utilizzato per mettere in pausa le particelle.

bool split_scale = false 🔗

  • void set_split_scale(value: bool)

  • bool get_split_scale()

Se impostato su true, è possibile specificare tre diverse curve di scala, una per ogni asse di scala.

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). Applicato al piano X/Z e ai piani Y/Z.

Curve tangential_accel_curve 🔗

L'accelerazione tangenziale di ogni particella varierà lungo questa Curve. Dovrebbe essere una Curve unitaria.

float tangential_accel_max = 0.0 🔗

Accelerazione tangenziale massima.

float tangential_accel_min = 0.0 🔗

Accelerazione tangenziale minima.

bool use_fixed_seed = false 🔗

  • void set_use_fixed_seed(value: bool)

  • bool get_use_fixed_seed()

Se true, le particelle utilizzeranno lo stesso seed per ogni simulazione, utilizzando il seed definito in seed. Ciò è utile per le situazioni in cui il risultato visivo deve essere coerente tra i replay, ad esempio quando si utilizza la modalità Movie Maker.

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

  • void set_visibility_aabb(value: AABB)

  • AABB get_visibility_aabb()

L'AABB che determina la regione del nodo che deve essere visibile sullo schermo affinché il sistema di particelle sia attivo.

Ingrandisci il box se le particelle appaiono o scompaiono all'improvviso quando il nodo entra o esce dallo schermo. L'AABB può essere ingrandito tramite codice o con lo strumento dell'editor Particelle → Genera AABB.

Descrizioni dei metodi

AABB capture_aabb() const 🔗

Restituisce la bounding box allineato all'asse che contiene tutte le particelle attive nel frame attuale.

void convert_from_particles(particles: Node) 🔗

Imposta le proprietà di questo nodo in modo che corrispondano a un dato nodo GPUParticles3D con un ParticleProcessMaterial assegnato.

Curve get_param_curve(param: Parameter) const 🔗

Restituisce la risorsa Curve del parametro specificato da Parameter.

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.

bool get_particle_flag(particle_flag: ParticleFlags) const 🔗

Restituisce lo stato abilitato del flag di particella specificato.

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) 🔗

Riavvia l'emettitore di particelle.

Se keep_seed è true, il seed casuale attuale verrà conservato. Utile per la ricerca e la riproduzione.

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

Imposta la risorsa Curve del parametro specificato da Parameter. Dovrebbe essere una Curve unitaria.

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

Imposta il valore massimo per il parametro specificato.

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

Imposta il valore minimo per il parametro specificato.

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

Abilita o disabilita il flag specificato.