CPUParticles2D

Hereda: Node2D < CanvasItem < Node < Object

Un emisor de partículas 2D basado en la CPU.

Descripción

Nodo de partículas 2D basado en CPU que se utiliza para crear diversos sistemas y efectos de partículas.

Véase también GPUParticles2D, que ofrece la misma funcionalidad con aceleración por hardware, pero podría no funcionar en dispositivos más antiguos.

Tutoriales

Propiedades

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

Métodos

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)

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)

Señales

finished() 🔗

Emitida cuando todas las partículas activas han terminado de procesarse. Cuando one_shot está desactivado, las partículas se procesarán continuamente, por lo que esto nunca se emite.

Enumeraciones

enum DrawOrder: 🔗

DrawOrder DRAW_ORDER_INDEX = 0

Las partículas se dibujan en el orden en que se emiten.

DrawOrder DRAW_ORDER_LIFETIME = 1

Las partículas se dibujan en orden de vida útil restante. En otras palabras, la partícula con la vida útil más alta se dibuja al frente.

enum Parameter: 🔗

Parameter PARAM_INITIAL_LINEAR_VELOCITY = 0

Utilizar con set_param_min(), set_param_max() y set_param_curve() para establecer las propiedades de la velocidad inicial.

Parameter PARAM_ANGULAR_VELOCITY = 1

Utilizar con set_param_min(), set_param_max() y set_param_curve() para establecer las propiedades de la velocidad angular.

Parameter PARAM_ORBIT_VELOCITY = 2

Utilizar con set_param_min(), set_param_max() y set_param_curve() para establecer las propiedades de la velocidad orbital.

Parameter PARAM_LINEAR_ACCEL = 3

Utilizar con set_param_min(), set_param_max() y set_param_curve() para establecer las propiedades de la aceleración lineal.

Parameter PARAM_RADIAL_ACCEL = 4

Utilizar con set_param_min(), set_param_max() y set_param_curve() para establecer las propiedades de la aceleración radial.

Parameter PARAM_TANGENTIAL_ACCEL = 5

Utilízalo con set_param_min(), set_param_max() y set_param_curve() para establecer propiedades de aceleración tangencial.

Parameter PARAM_DAMPING = 6

Utilízalo con set_param_min(), set_param_max() y set_param_curve() para establecer propiedades de amortiguación.

Parameter PARAM_ANGLE = 7

Utilízalo con set_param_min(), set_param_max() y set_param_curve() para establecer propiedades de ángulo.

Parameter PARAM_SCALE = 8

Utilízalo con set_param_min(), set_param_max() y set_param_curve() para establecer propiedades de escala.

Parameter PARAM_HUE_VARIATION = 9

Utilízalo con set_param_min(), set_param_max() y set_param_curve() para establecer propiedades de variación de tono.

Parameter PARAM_ANIM_SPEED = 10

Utilízalo con set_param_min(), set_param_max() y set_param_curve() para establecer las propiedades de velocidad de la animación.

Parameter PARAM_ANIM_OFFSET = 11

Utilízalo con set_param_min(), set_param_max() y set_param_curve() para establecer las propiedades de desplazamiento de la animación.

Parameter PARAM_MAX = 12

Representa el tamaño del enumerado Parameter.

enum ParticleFlags: 🔗

ParticleFlags PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY = 0

Utilizar con set_particle_flag() para establecer particle_flag_align_y.

ParticleFlags PARTICLE_FLAG_ROTATE_Y = 1

Presente por coherencia con los nodos de partículas en 3D, no usado en 2D.

ParticleFlags PARTICLE_FLAG_DISABLE_Z = 2

Presente por coherencia con los nodos de partículas en 3D, no usado en 2D.

ParticleFlags PARTICLE_FLAG_MAX = 3

Representa el tamaño del enum ParticleFlags.

enum EmissionShape: 🔗

EmissionShape EMISSION_SHAPE_POINT = 0

Todas las partículas serán emitidas desde un único punto.

EmissionShape EMISSION_SHAPE_SPHERE = 1

Las partículas se emitirán en el volumen de una esfera aplanada en dos dimensiones.

EmissionShape EMISSION_SHAPE_SPHERE_SURFACE = 2

Se emitirán partículas en la superficie de una esfera aplanada en dos dimensiones.

EmissionShape EMISSION_SHAPE_RECTANGLE = 3

Se emitirán partículas en el área de un rectángulo.

EmissionShape EMISSION_SHAPE_POINTS = 4

Las partículas se emitirán en una posición elegida al azar entre emission_points. El color de las partículas será modulado por emission_colors.

EmissionShape EMISSION_SHAPE_DIRECTED_POINTS = 5

Las partículas se emitirán en una posición elegida al azar entre emission_points. La velocidad y rotación de las partículas se fijarán en base a emission_normals. El color de las partículas será modulado por 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

Representa el tamaño del enum EmissionShape.

Descripciones de Propiedades

int amount = 8 🔗

  • void set_amount(value: int)

  • int get_amount()

Número de partículas emitidas en un ciclo de emisión.

Curve angle_curve 🔗

La rotación de cada partícula se animará a lo largo de esta Curve. Debe ser una Curve unitaria.

float angle_max = 0.0 🔗

Rotación inicial máxima aplicada a cada partícula, en grados.

float angle_min = 0.0 🔗

Equivalente mínimo de angle_max.

Curve angular_velocity_curve 🔗

La velocidad angular de cada partícula variará a lo largo de esta Curve. Debe ser una Curve unitaria.

float angular_velocity_max = 0.0 🔗

Velocidad angular inicial máxima (velocidad de rotación) aplicada a cada partícula en grados por segundo.

float angular_velocity_min = 0.0 🔗

Equivalente mínimo de angular_velocity_max.

Curve anim_offset_curve 🔗

El desplazamiento de animación de cada partícula variará a lo largo de esta Curve. Debe ser una Curve unitaria.

float anim_offset_max = 0.0 🔗

Desplazamiento máximo de animación correspondiente al índice de fotograma en la textura. 0 es el primer fotograma, 1 es el último. Véase CanvasItemMaterial.particles_animation.

float anim_offset_min = 0.0 🔗

Equivalente mínimo de anim_offset_max.

Curve anim_speed_curve 🔗

La velocidad de animación de cada partícula variará a lo largo de esta Curve. Debe ser una Curve unitaria.

float anim_speed_max = 0.0 🔗

Velocidad máxima de animación de partículas. Una velocidad de animación de 1 significa que las partículas completarán un ciclo completo de 0 a 1 durante su vida útil; 2 significa 2 ciclos, etc.

Si la velocidad de animación es superior a 1, recuerda habilitar la propiedad CanvasItemMaterial.particles_anim_loop si deseas que la animación se repita.

float anim_speed_min = 0.0 🔗

Equivalente mínimo de anim_speed_max.

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

El color inicial de cada partícula. Si se define texture, se multiplicará por este color.

Gradient color_initial_ramp 🔗

  • void set_color_initial_ramp(value: Gradient)

  • Gradient get_color_initial_ramp()

El color inicial de cada partícula variará a lo largo de este Gradient (multiplicado por color).

Gradient color_ramp 🔗

El color de cada partícula variará a lo largo de este Gradient durante su vida útil (multiplicado por color).

Curve damping_curve 🔗

La amortiguación variará a lo largo de esta Curve. Debe ser una unidad Curve.

float damping_max = 0.0 🔗

La velocidad máxima a la que las partículas pierden velocidad. Por ejemplo, un valor de 100 significa que la partícula pasará de 100 de velocidad a 0 en 1 segundo.

float damping_min = 0.0 🔗

Equivalente mínimo de damping_max.

Vector2 direction = Vector2(1, 0) 🔗

Vector unitario que especifica la dirección de emisión de las partículas.

DrawOrder draw_order = 0 🔗

Orden de dibujado de partículas.

PackedColorArray emission_colors 🔗

Establece los Colors para modular las partículas al usar 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 🔗

Establece la dirección en la que las partículas serán emitidas cuando se use 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 🔗

Establece las posiciones iniciales para generar partículas cuando se utiliza 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()

La extensión del rectángulo si emission_shape se fija en 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 🔗

Se emitirán partículas dentro de esta región.

float emission_sphere_radius 🔗

  • void set_emission_sphere_radius(value: float)

  • float get_emission_sphere_radius()

El radio de la esfera si emission_shape se fija en EMISSION_SHAPE_SPHERE.

bool emitting = true 🔗

  • void set_emitting(value: bool)

  • bool is_emitting()

Si es true, se están emitiendo partículas. emitting se puede usar para iniciar y detener la emisión de partículas. Sin embargo, si one_shot es true, establecer emitting como true no reiniciará el ciclo de emisión hasta que todas las partículas activas terminen de procesarse. Puedes usar la señal finished para recibir una notificación cuando todas las partículas activas terminen de procesarse.

float explosiveness = 0.0 🔗

  • void set_explosiveness_ratio(value: float)

  • float get_explosiveness_ratio()

La rapidez con la que se emiten las partículas en un ciclo de emisión. Si es mayor que 0, habrá una espacio de tiempo en las emisiones antes de que comience el siguiente ciclo.

int fixed_fps = 0 🔗

  • void set_fixed_fps(value: int)

  • int get_fixed_fps()

La velocidad de fotogramas del sistema de partículas se fija a un valor. Por ejemplo, cambiar el valor a 2 hará que las partículas se rendericen a 2 fotogramas por segundo. Ten en cuenta que esto no ralentiza la simulación del sistema de partículas en sí.

bool fract_delta = true 🔗

  • void set_fractional_delta(value: bool)

  • bool get_fractional_delta()

Si es true, resulta en un cálculo delta fraccionario que tiene un efecto de visualización de partículas más suave.

Vector2 gravity = Vector2(0, 980) 🔗

La gravedad aplicada a cada partícula.

Curve hue_variation_curve 🔗

El tono de cada partícula variará a lo largo de esta Curve. Debe ser una Curve unitaria.

float hue_variation_max = 0.0 🔗

Variación máxima inicial de tono aplicada a cada partícula. Desplazará el tono del color de la partícula.

float hue_variation_min = 0.0 🔗

Equivalente mínimo de hue_variation_max.

float initial_velocity_max = 0.0 🔗

Magnitud máxima de la velocidad inicial para cada partícula. La dirección viene de direction y spread.

float initial_velocity_min = 0.0 🔗

Equivalente mínimo de initial_velocity_max.

float lifetime = 1.0 🔗

  • void set_lifetime(value: float)

  • float get_lifetime()

Cantidad de tiempo que cada partícula existirá.

float lifetime_randomness = 0.0 🔗

  • void set_lifetime_randomness(value: float)

  • float get_lifetime_randomness()

El ratio de aleatoriedad del tiempo de vida de las partículas.

Curve linear_accel_curve 🔗

La aceleración lineal de cada partícula variará a lo largo de esta Curve. Debe ser una Curve unitaria.

float linear_accel_max = 0.0 🔗

Aceleración lineal máxima aplicada a cada partícula en la dirección del movimiento.

float linear_accel_min = 0.0 🔗

Equivalente mínimo de linear_accel_max.

bool local_coords = false 🔗

  • void set_use_local_coordinates(value: bool)

  • bool get_use_local_coordinates()

Si es true, las partículas usan el espacio de coordenadas del nodo padre (conocido como coordenadas locales). Esto hará que las partículas se muevan y giren junto con el nodo CPUParticles2D (y sus padres) cuando este se mueva o gire. Si es false, las partículas usan coordenadas globales; no se moverán ni girarán junto con el nodo CPUParticles2D (y sus padres) cuando este se mueva o gire.

bool one_shot = false 🔗

  • void set_one_shot(value: bool)

  • bool get_one_shot()

Si es true, sólo se produce un ciclo de emisión. Si se establece true durante un ciclo, la emisión se detendrá al final del ciclo.

Curve orbit_velocity_curve 🔗

La velocidad orbital de cada partícula variará a lo largo de esta Curve. Debe ser una Curve unitaria.

float orbit_velocity_max = 0.0 🔗

Velocidad orbital máxima aplicada a cada partícula. Hace que las partículas giren alrededor del origen. Se especifica en número de rotaciones completas alrededor del origen por segundo.

float orbit_velocity_min = 0.0 🔗

Equivalente mínimo de orbit_velocity_max.

bool particle_flag_align_y = false 🔗

Alinea el eje Y de la partícula con la dirección de su velocidad.

float preprocess = 0.0 🔗

  • void set_pre_process_time(value: float)

  • float get_pre_process_time()

El sistema de partículas se inicia como si ya hubiera funcionado durante este número de segundos.

Curve radial_accel_curve 🔗

La aceleración radial de cada partícula variará a lo largo de esta Curve. Debe ser una Curve unitaria.

float radial_accel_max = 0.0 🔗

Aceleración radial máxima aplicada a cada partícula. Hace que la partícula se acelere alejándose del origen o hacia él si es negativa.

float radial_accel_min = 0.0 🔗

Equivalente mínimo de radial_accel_max.

float randomness = 0.0 🔗

  • void set_randomness_ratio(value: float)

  • float get_randomness_ratio()

Proporción de aleatoriedad de la vida útil de las emisiones.

Curve scale_amount_curve 🔗

La escala de cada partícula variará a lo largo de esta Curve. Debe ser una Curve unitaria.

float scale_amount_max = 1.0 🔗

Escala inicial máxima aplicada a cada partícula.

float scale_amount_min = 1.0 🔗

Equivalente mínimo de scale_amount_max.

Curve scale_curve_x 🔗

  • void set_scale_curve_x(value: Curve)

  • Curve get_scale_curve_x()

La escala horizontal de cada partícula variará a lo largo de esta Curve. Debe ser una Curve unitaria.

split_scale debe estar habilitado.

Curve scale_curve_y 🔗

  • void set_scale_curve_y(value: Curve)

  • Curve get_scale_curve_y()

La escala vertical de cada partícula variará a lo largo de esta Curve. Debe ser una Curve unitaria.

split_scale debe estar habilitado.

int seed = 0 🔗

  • void set_seed(value: int)

  • int get_seed()

Establece la semilla aleatoria utilizada por el sistema de partículas. Solo es efectivo si use_fixed_seed es true.

float speed_scale = 1.0 🔗

  • void set_speed_scale(value: float)

  • float get_speed_scale()

El sistema de partículas está funcionando a una velocidad de escalada. Un valor de 0 puede ser usado para pausar las partículas.

bool split_scale = false 🔗

  • void set_split_scale(value: bool)

  • bool get_split_scale()

Si es true, la curva de escala se dividirá en componentes x e y. Véase scale_curve_x y scale_curve_y.

float spread = 45.0 🔗

  • void set_spread(value: float)

  • float get_spread()

La dirección inicial de cada partícula va desde +spread hasta -spread grados.

Curve tangential_accel_curve 🔗

La aceleración tangencial de cada partícula variará a lo largo de esta Curve. Debe ser una Curve unitaria.

float tangential_accel_max = 0.0 🔗

Aceleración tangencial máxima aplicada a cada partícula. La aceleración tangencial es perpendicular a la velocidad de la partícula, lo que les da a las partículas un movimiento de remolino.

float tangential_accel_min = 0.0 🔗

Equivalente mínimo de tangential_accel_max.

Texture2D texture 🔗

La textura de las partículas. Si null, las partículas serán cuadradas.

bool use_fixed_seed = false 🔗

  • void set_use_fixed_seed(value: bool)

  • bool get_use_fixed_seed()

Si es true, las partículas usarán la misma semilla para cada simulación utilizando la semilla definida en seed. Esto es útil para situaciones en las que el resultado visual debe ser consistente en las repeticiones, por ejemplo, cuando se utiliza el modo Movie Maker.

Descripciones de Métodos

void convert_from_particles(particles: Node) 🔗

Establece las propiedades de este nodo para que coincidan con un nodo GPUParticles2D determinado con un ParticleProcessMaterial asignado.

Curve get_param_curve(param: Parameter) const 🔗

Devuelve la Curve del parámetro especificado por Parameter.

float get_param_max(param: Parameter) const 🔗

Devuelve el rango de valores máximo para el parámetro dado.

float get_param_min(param: Parameter) const 🔗

Devuelve el rango de valores mínimo para el parámetro dado.

bool get_particle_flag(particle_flag: ParticleFlags) const 🔗

Devuelve el estado habilitado de la bandera de partícula dada.

void request_particles_process(process_time: float) 🔗

Solicita a las partículas que se procesen durante un tiempo adicional durante un solo fotograma.

Útil para la reproducción de partículas si se usa en combinación con use_fixed_seed o al llamar a restart() con el parámetro keep_seed establecido en true.

void restart(keep_seed: bool = false) 🔗

Reinicia el emisor de partículas.

Si keep_seed es true, se conservará la semilla aleatoria actual. Útil para búsquedas y reproducción.

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

Establece la Curve del parámetro especificado por Parameter. Debe ser una Curve unitaria.

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

Establece el valor máximo para el parámetro dado.

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

Establece el valor mínimo para el parámetro dado.

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

Habilita o deshabilita la bandera dada.