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

GPUParticles3D

Eredita: GeometryInstance3D < VisualInstance3D < Node3D < Node < Object

Un emettitore di particelle 3D.

Descrizione

Nodo di particelle 3D utilizzato per creare una varietà di sistemi di particelle ed effetti. GPUParticles3D è 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.

Tutorial

Proprietà

int

amount

8

float

amount_ratio

1.0

float

collision_base_size

0.01

DrawOrder

draw_order

0

Mesh

draw_pass_1

Mesh

draw_pass_2

Mesh

draw_pass_3

Mesh

draw_pass_4

int

draw_passes

1

Skin

draw_skin

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("")

bool

trail_enabled

false

float

trail_lifetime

0.3

TransformAlign

transform_align

0

ParticlesTransformAlignAxis

transform_align_axis

ParticlesTransformAlignCustomSrc

transform_align_channel_filter

bool

use_fixed_seed

false

AABB

visibility_aabb

AABB(-4, -4, -4, 8, 8, 8)

Metodi

AABB

capture_aabb() const

void

convert_from_particles(particles: Node)

void

emit_particle(xform: Transform3D, velocity: Vector3, color: Color, custom: Color, flags: int)

Mesh

get_draw_pass_mesh(pass: int) const

void

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

void

restart(keep_seed: bool = false)

void

set_draw_pass_mesh(pass: int, mesh: Mesh)

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.

DrawOrder DRAW_ORDER_VIEW_DEPTH = 3

Le particelle sono disegnate in ordine di profondità.

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.

enum TransformAlign: 🔗

TransformAlign TRANSFORM_ALIGN_DISABLED = 0

Do not align particle transforms relative to the camera or velocity.

TransformAlign TRANSFORM_ALIGN_Z_BILLBOARD = 1

Align each particle's Z axis to face the camera.

TransformAlign TRANSFORM_ALIGN_Y_TO_VELOCITY = 2

Align each particle's Y axis to the velocity vector.

TransformAlign TRANSFORM_ALIGN_Z_BILLBOARD_Y_TO_VELOCITY = 3

Align each particle's Z axis to face the camera and Y axis to the velocity vector.

TransformAlign TRANSFORM_ALIGN_LOCAL_BILLBOARD = 4

Align each particle's Z axis to face the camera, while preserving a given axis (X or Y).

Costanti

MAX_DRAW_PASSES = 4 🔗

Numero massimo di passaggi di disegno supportati.

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

  • void set_collision_base_size(value: float)

  • float get_collision_base_size()

Diametro di base per la collisione delle particelle in metri. Se le particelle sembrano affondare nel terreno durante la collisione, aumenta questo valore. Se le particelle sembrano galleggiare durante la collisione, 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 = 0 🔗

Ordine di disegno delle particelle.

Nota: DRAW_ORDER_INDEX è l'unica opzione che supporta i vettori di movimento per effetti come TAA. Si consiglia di utilizzare questo ordine di disegno se le particelle sono opache per correggere gli artefatti di "ghosting".

Mesh draw_pass_1 🔗

  • void set_draw_pass_mesh(pass: int, mesh: Mesh)

  • Mesh get_draw_pass_mesh(pass: int) const

La Mesh disegnata per il primo passaggio di disegno.

Mesh draw_pass_2 🔗

  • void set_draw_pass_mesh(pass: int, mesh: Mesh)

  • Mesh get_draw_pass_mesh(pass: int) const

La Mesh disegnata per il secondo passaggio di disegno.

Mesh draw_pass_3 🔗

  • void set_draw_pass_mesh(pass: int, mesh: Mesh)

  • Mesh get_draw_pass_mesh(pass: int) const

La Mesh disegnata per il terzo passaggio di disegno.

Mesh draw_pass_4 🔗

  • void set_draw_pass_mesh(pass: int, mesh: Mesh)

  • Mesh get_draw_pass_mesh(pass: int) const

La Mesh disegnata per il quarto passaggio di disegno.

int draw_passes = 1 🔗

  • void set_draw_passes(value: int)

  • int get_draw_passes()

Il numero di passaggi di disegno durante il rendering delle particelle.

Skin draw_skin 🔗

  • void set_skin(value: Skin)

  • Skin get_skin()

There is currently no description for this property. Please help us by contributing one!

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

Rapporto di tempo tra ogni emissione. Se 0, le particelle sono emesse continuamente. Se 1, tutte le particelle sono emesse allo stesso tempo.

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 GPUParticles3D (e i suoi genitori) quando viene spostato o ruotato. Se false, le particelle usano coordinate globali; non si muoveranno o ruoteranno lungo il nodo GPUParticles3D (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, verrà emesso solamente il numero di particelle uguali a amount.

float preprocess = 0.0 🔗

  • void set_pre_process_time(value: float)

  • float get_pre_process_time()

Quantità di tempo per pre-elaborare le particelle prima che cominci l'animazione. Ti consente di avviare l'animazione un po' di tempo dopo che le particelle hanno cominciato l'emissione.

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à 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 di scala della velocità. Un valore di 0 può essere utilizzato per mettere in pausa le particelle.

NodePath sub_emitter = NodePath("") 🔗

Percorso verso un altro nodo GPUParticles3D 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 GPUParticles3D non emetterà più particelle da solo.

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. Progettato per funzionare con RibbonTrailMesh e TubeTrailMesh.

Nota: BaseMaterial3D.use_particle_trails deve essere abilitato anche sul materiale della mesh di particelle. Altrimenti, impostare trail_enabled su true non avrà alcun effetto.

Nota: A differenza di GPUParticles2D, il numero di sezioni e suddivisioni della scia è impostato nelle proprietà del RibbonTrailMesh o del TubeTrailMesh.

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.

TransformAlign transform_align = 0 🔗

The alignment of particles. Use this for billboarding and aligning to velocity.

ParticlesTransformAlignAxis transform_align_axis 🔗

When using transform align local billboard, which axis to use for the billboarding. Supports only X or Y.

ParticlesTransformAlignCustomSrc transform_align_channel_filter 🔗

In the case of billboarded particles, which custom channel to read from to calculate their angle.

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(-4, -4, -4, 8, 8, 8) 🔗

  • 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. GeometryInstance3D.extra_cull_margin è aggiunto su ciascuno degli assi di AABB. Le collisioni e l'attrazione delle particelle si verificheranno solo all'interno di quest'area.

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

Nota: visibility_aabb è sovrascritto da GeometryInstance3D.custom_aabb se tale proprietà è impostata su un valore non predefinito.

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

void emit_particle(xform: Transform3D, velocity: Vector3, 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à.

Mesh get_draw_pass_mesh(pass: int) const 🔗

Restituisce la Mesh disegnata all'indice pass.

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

void set_draw_pass_mesh(pass: int, mesh: Mesh) 🔗

Imposta la Mesh disegnata all'indice pass.