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

CPUParticles2D

Eredita: Node2D < CanvasItem < Node < Object

Un emettitore di particelle 2D basato su CPU.

Descrizione

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

Vedi anche GPUParticles2D, 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

Vector2

direction

Vector2(1, 0)

DrawOrder

draw_order

0

PackedColorArray

emission_colors

PackedVector2Array

emission_normals

PackedVector2Array

emission_points

Vector2

emission_rect_extents

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

bool

fract_delta

true

Vector2

gravity

Vector2(0, 980)

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

bool

one_shot

false

Curve

orbit_velocity_curve

float

orbit_velocity_max

0.0

float

orbit_velocity_min

0.0

bool

particle_flag_align_y

false

PhysicsInterpolationMode

physics_interpolation_mode

2 (overrides Node)

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

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

Texture2D

texture

bool

use_fixed_seed

false

Metodi

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.

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

Presente per coerenza con i nodi delle particelle 3D, mai utilizzato in 2D.

ParticleFlags PARTICLE_FLAG_DISABLE_Z = 2

Presente per coerenza con i nodi delle particelle 3D, mai utilizzato in 2D.

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 appiattita a due dimensioni.

EmissionShape EMISSION_SHAPE_SPHERE_SURFACE = 2

Le particelle saranno emesse sulla superfice di una sfera appiattita a due dimensioni.

EmissionShape EMISSION_SHAPE_RECTANGLE = 3

Le particelle saranno emesse nell'area di un rettangolo.

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

Particles will be emitted in the area of a ring parameterized by its outer and inner radius.

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 🔗

Rotazione iniziale massima applicata a ciascuna particella, in gradi.

float angle_min = 0.0 🔗

Equivalente minimo di angle_max.

Curve angular_velocity_curve 🔗

La velocità angolare di ciascuna particella varierà lungo questa Curve. 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 🔗

Equivalente minimo di angular_velocity_max.

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

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

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

Colore iniziale di ciascuna particella. Se texture è definito, sarà moltiplicato per questo colore.

Gradient color_initial_ramp 🔗

  • void set_color_initial_ramp(value: Gradient)

  • Gradient get_color_initial_ramp()

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

Gradient color_ramp 🔗

Il colore di ciascuna particella varierà lungo questo Gradient nel corso della sua durata (moltiplicato per color).

Curve damping_curve 🔗

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

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.

Vector2 direction = Vector2(1, 0) 🔗

Vettore unitario che specifica la direzione di emissione delle particelle.

DrawOrder draw_order = 0 🔗

Ordine di disegno delle particelle.

PackedColorArray emission_colors 🔗

Imposta i Color con cui modulare 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 PackedColorArray for more details.

PackedVector2Array 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 PackedVector2Array for more details.

PackedVector2Array 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 PackedVector2Array for more details.

Vector2 emission_rect_extents 🔗

  • void set_emission_rect_extents(value: Vector2)

  • Vector2 get_emission_rect_extents()

Le estensioni del rettangolo se emission_shape è impostato su EMISSION_SHAPE_RECTANGLE.

float emission_ring_inner_radius 🔗

  • void set_emission_ring_inner_radius(value: float)

  • float get_emission_ring_inner_radius()

The ring's inner radius if emission_shape is set to EMISSION_SHAPE_RING.

float emission_ring_radius 🔗

  • void set_emission_ring_radius(value: float)

  • float get_emission_ring_radius()

The ring's outer radius if emission_shape is set to 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 emission_shape è 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.

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.

Vector2 gravity = Vector2(0, 980) 🔗

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 🔗

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 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 = 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 applicata a ciascuna particella nella direzione del movimento.

float linear_accel_min = 0.0 🔗

Equivalente minimo di linear_accel_max.

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

Curve orbit_velocity_curve 🔗

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

float orbit_velocity_max = 0.0 🔗

Velocità orbitale massima applicata a ciascuna particella. Fa in modo che le particelle girino attorno all'origine. Specificata in numero di rotazioni complete attorno all'origine al secondo.

float orbit_velocity_min = 0.0 🔗

Equivalente minimo di orbit_velocity_max.

bool particle_flag_align_y = false 🔗

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

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

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 iniziale massima applicata a ciascuna particella.

float scale_amount_min = 1.0 🔗

Equivalente minimo di scale_amount_max.

Curve scale_curve_x 🔗

  • void set_scale_curve_x(value: Curve)

  • Curve get_scale_curve_x()

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

split_scale deve essere abilitato.

Curve scale_curve_y 🔗

  • void set_scale_curve_y(value: Curve)

  • Curve get_scale_curve_y()

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

split_scale deve essere abilitato.

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 true, la curva della scala sarà divisa in componenti x e y. Vedi scale_curve_x e scale_curve_y.

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

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

Texture2D texture 🔗

Texture delle particelle. Se null, le particelle saranno quadrati.

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.

Descrizioni dei metodi

void convert_from_particles(particles: Node) 🔗

Imposta le proprietà di questo nodo in modo che corrispondano a un dato nodo GPUParticles2D 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.