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

GPUParticles2D

Eredita: Node2D < CanvasItem < Node < Object

Un emettitore di particelle 2D.

Descrizione

Nodo di particelle 2D utilizzato per creare una varietà di sistemi di particelle ed effetti. GPUParticles2D è dotato di un emettitore che genera un certo numero di particelle a una determinata frequenza.

Usa process_material per aggiungere un ParticleProcessMaterial per configurare l'aspetto e il comportamento delle particelle. In alternativa, è possibile aggiungere uno ShaderMaterial che sarà applicato a tutte le particelle.

Le particelle 2D possono opzionalmente collidere con LightOccluder2D, ma non con i nodi PhysicsBody2D.

Tutorial

Proprietà

int

amount

8

float

amount_ratio

1.0

float

collision_base_size

1.0

DrawOrder

draw_order

1

bool

emitting

true

float

explosiveness

0.0

int

fixed_fps

30

bool

fract_delta

true

float

interp_to_end

0.0

bool

interpolate

true

float

lifetime

1.0

bool

local_coords

false

bool

one_shot

false

float

preprocess

0.0

Material

process_material

float

randomness

0.0

int

seed

0

float

speed_scale

1.0

NodePath

sub_emitter

NodePath("")

Texture2D

texture

bool

trail_enabled

false

float

trail_lifetime

0.3

int

trail_section_subdivisions

4

int

trail_sections

8

bool

use_fixed_seed

false

Rect2

visibility_rect

Rect2(-100, -100, 200, 200)

Metodi

Rect2

capture_rect() const

void

convert_from_particles(particles: Node)

void

emit_particle(xform: Transform2D, velocity: Vector2, color: Color, custom: Color, flags: int)

void

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

void

restart(keep_seed: bool = false)

Segnali

finished() 🔗

Emesso quando tutte le particelle attive hanno terminato l'elaborazione. Per riavviare immediatamente il ciclo di emissione, chiama restart().

Questo segnale non è mai emesso quando one_shot è disabilitato, poiché le particelle verranno emesse ed elaborate continuamente.

Nota: Per gli emettitori con one_shot abilitato, poiché le particelle vengono elaborate sulla GPU, potrebbe esserci un breve periodo dopo la ricezione del segnale durante il quale l'impostazione di emitting su true non riavvierà il ciclo di emissione. Questo ritardo è evitato chiamando invece restart().

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_REVERSE_LIFETIME = 2

Le particelle sono disegnate in ordine inverso rispetto alla durata residua. In altre parole, la particella con la durata più bassa è disegnata di fronte.

enum EmitFlags: 🔗

EmitFlags EMIT_FLAG_POSITION = 1

La particella inizia alla posizione specificata.

EmitFlags EMIT_FLAG_ROTATION_SCALE = 2

La particella inizia con la rotazione e la scala specificate.

EmitFlags EMIT_FLAG_VELOCITY = 4

La particella inizia con il vettore di velocità specificato, che definisce la direzione e la velocità di emissione.

EmitFlags EMIT_FLAG_COLOR = 8

La particella inizia con il colore specificato.

EmitFlags EMIT_FLAG_CUSTOM = 16

La particella inizia con i dati CUSTOM specificati.

Descrizioni delle proprietà

int amount = 8 🔗

  • void set_amount(value: int)

  • int get_amount()

Numero di particelle da emettere in un ciclo di emissione. La frequenza di emissione effettiva è (quantità* rapporto_di_quantità) / tempo_di_vita particelle al secondo. Valori più alti aumenteranno i requisiti sulla GPU, anche se non tutte le particelle sono visibili in un determinato momento o se amount_ratio viene diminuito.

Nota: La modifica di questo valore causerà il riavvio del sistema di particelle. Per evitarlo, modifica invece amount_ratio.

float amount_ratio = 1.0 🔗

  • void set_amount_ratio(value: float)

  • float get_amount_ratio()

Il rapporto di particelle che dovrebbero essere effettivamente emesse. Se impostato su un valore inferiore a 1.0, questo imposterà la quantità di particelle emesse durante la durata a quantità * rapporto_di_quantità. A differenza di modificare amount, modificare amount_ratio durante l'emissione non influisce sulle particelle già emesse e non causa il riavvio del sistema di particelle. amount_ratio può essere utilizzato per creare effetti che fanno variare il numero di particelle emesse nel tempo.

Nota: Ridurre amount_ratio non ha alcun vantaggio in termini di prestazioni, poiché le risorse devono essere allocate ed elaborate per il totale di amount di particelle indipendentemente da amount_ratio. Se non intendi modificare il numero di particelle emesse durante l'emissione, assicurati che amount_ratio sia impostato su 1 e modifica invece amount a tuo piacimento.

float collision_base_size = 1.0 🔗

  • void set_collision_base_size(value: float)

  • float get_collision_base_size()

Moltiplicatore per il raggio di collisione delle particelle. 1.0 corrisponde alla dimensione dello sprite. Se le particelle sembrano affondare nel terreno quando si scontrano, aumenta questo valore. Se le particelle sembrano galleggiare quando si scontrano, diminuisci questo valore. Efficace solo se ParticleProcessMaterial.collision_mode è ParticleProcessMaterial.COLLISION_RIGID o ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT.

Nota: Le particelle hanno sempre una forma di collisione sferica.

DrawOrder draw_order = 1 🔗

Ordine di disegno delle particelle.

bool emitting = true 🔗

  • void set_emitting(value: bool)

  • bool is_emitting()

Se true, le particelle vengono emesse. emitting può essere utilizzato per avviare e interrompere l'emissione di particelle. Tuttavia, se one_shot è true, impostare emitting su true non riavvierà il ciclo di emissione a meno che tutte le particelle attive non abbiano terminato l'elaborazione. Utilizza il segnale finished per essere avvisato una volta che tutte le particelle attive hanno terminato l'elaborazione.

Nota: Per gli emettitori con one_shot abilitato, poiché le particelle vengono elaborate sulla GPU, potrebbe esserci un breve periodo dopo la ricezione del segnale finished durante il quale impostare su true non riavvierà il ciclo di emissione.

Suggerimento: Se l'emettitore con one_shot abilitato deve riavviare immediatamente l'emissione di particelle una volta ricevuto il segnale finished, considera di chiamare restart() anziché impostare emitting.

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 = 30 🔗

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

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.

float interp_to_end = 0.0 🔗

  • void set_interp_to_end(value: float)

  • float get_interp_to_end()

Provoca l'interpolazione di tutte le particelle in questo nodo verso la fine del loro ciclo di vita.

Nota: Funziona solo se utilizzato con un ParticleProcessMaterial. Deve essere implementato manualmente per gli shader di processo personalizzati.

bool interpolate = true 🔗

  • void set_interpolate(value: bool)

  • bool get_interpolate()

"Abilita l'interpolazione delle particelle, che rende il movimento delle particelle più fluido quando il loro fixed_fps è inferiore alla frequenza di aggiornamento dello schermo.

float lifetime = 1.0 🔗

  • void set_lifetime(value: float)

  • float get_lifetime()

La quantità di tempo per cui ogni particella esisterà (in secondi). La frequenza di emissione effettiva è (quantità * rapporto_di_quantità) / tempo_di_vita particelle al secondo.

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 GPUParticles2D (e i suoi genitori) quando viene spostato o ruotato. Se false, le particelle usano coordinate globali; non si muoveranno o ruoteranno lungo il nodo GPUParticles2D (e i suoi genitori) quando viene spostato o ruotato.

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.

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.

Nota: Questo può essere molto costoso se impostato su un numero elevato, poiché richiede l'esecuzione dello shader di particelle un numero di volte pari a fixed_fps (o 30, se fixed_fps è 0) per ogni secondo. In casi estremi può persino causare un arresto anomalo della GPU a causa del volume di lavoro svolto in un singolo frame.

Material process_material 🔗

Il Material per l'elaborazione delle particelle. Può essere un ParticleProcessMaterial o uno ShaderMaterial.

float randomness = 0.0 🔗

  • void set_randomness_ratio(value: float)

  • float get_randomness_ratio()

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

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.

NodePath sub_emitter = NodePath("") 🔗

Percorso verso un altro nodo GPUParticles2D che sarà utilizzato come sottoemettitore (vedi ParticleProcessMaterial.sub_emitter_mode). I sottoemettitori possono essere utilizzati per ottenere effetti quali fuochi d'artificio, scintille in caso di collisione, bolle che scoppiano in gocce d'acqua e altro ancora.

Nota: Quando sub_emitter è impostato, il nodo di destinazione GPUParticles2D non emetterà più particelle da solo.

Texture2D texture 🔗

Texture delle particelle. Se null, le particelle saranno quadrati con una dimensione di 1×1 pixel.

Nota: Per usare una texture tipo libro sfogliabile, assegna un nuovo CanvasItemMaterial alla proprietà CanvasItem.material del GPUParticles2D, quindi abilita CanvasItemMaterial.particles_animation e imposta CanvasItemMaterial.particles_anim_h_frames, CanvasItemMaterial.particles_anim_v_frames e CanvasItemMaterial.particles_anim_loop in modo che corrispondano alla texture tipo libro sfogliabile.

bool trail_enabled = false 🔗

  • void set_trail_enabled(value: bool)

  • bool is_trail_enabled()

Se true, abilita le scie di particelle usando un sistema di skinning mesh.

Nota: A differenza di GPUParticles3D, il numero di sezioni e suddivisioni della scia è impostato con le proprietà trail_sections e trail_section_subdivisions.

float trail_lifetime = 0.3 🔗

  • void set_trail_lifetime(value: float)

  • float get_trail_lifetime()

La quantità di tempo che la scia di particelle dovrebbe rappresentare (in secondi). Efficace solo se trail_enabled è true.

int trail_section_subdivisions = 4 🔗

  • void set_trail_section_subdivisions(value: int)

  • int get_trail_section_subdivisions()

Il numero di suddivisioni da utilizzare per il rendering della scia di particelle. Valori più alti possono risultare in curve di scie più fluide, a scapito delle prestazioni a causa della mesh più complessa. Vedi anche trail_sections. Efficace solo se trail_enabled è true.

int trail_sections = 8 🔗

  • void set_trail_sections(value: int)

  • int get_trail_sections()

Il numero di sezioni da utilizzare per il rendering della scia di particelle. Valori più alti possono risultare in curve di scie più fluide, a scapito delle prestazioni a causa della mesh più complessa. Vedi anche trail_section_subdivisions. Efficace solo se trail_enabled è true.

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.

Rect2 visibility_rect = Rect2(-100, -100, 200, 200) 🔗

  • void set_visibility_rect(value: Rect2)

  • Rect2 get_visibility_rect()

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

Aumenta il rettangolo se le particelle appaiono o scompaiono all'improvviso quando il nodo entra o esce dallo schermo. Il Rect2 può essere aumentato tramite codice o con lo strumento dell'editor Particelle → Genera rettangolo di visibilità.

Descrizioni dei metodi

Rect2 capture_rect() const 🔗

Restituisce un rettangolo contenente le posizioni di tutte le particelle esistenti.

Nota: Quando si usa il rendering su un altro thread, questo metodo sincronizza il thread di rendering. Chiamarlo spesso può avere un impatto negativo sulle prestazioni.

void convert_from_particles(particles: Node) 🔗

Imposta le proprietà di questo nodo in modo che corrispondano a un dato nodo CPUParticles2D.

void emit_particle(xform: Transform2D, velocity: Vector2, color: Color, custom: Color, flags: int) 🔗

Emette una singola particella. L'applicazione della trasformazione (xform), la velocità (velocity), il colore (color) e custom dipende dal valore di flags. Vedi EmitFlags.

Il ParticleProcessMaterial predefinito sovrascriverà color e utilizzerà il contenuto di custom come (rotazione, tempo iniziale, animazione, tempo di vita).

Nota: emit_particle() è supportato solo sui metodi di rendering Forward+ e Mobile, non su Compatibilità.

void request_particles_process(process_time: float, process_time_residual: float = 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 il ciclo di emissione delle particelle, eliminando le particelle esistenti. Per evitare che le particelle scompaiano dalla viewport, attendi il segnale finished prima di chiamare questo metodo.

Nota: Il segnale finished viene emesso solo dagli emettitori con one_shot abilitato.

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