CPUParticles3D

Hereda: GeometryInstance3D < VisualInstance3D < Node3D < Node < Object

Un emisor de partículas 3D que utiliza la CPU.

Descripción

Nodo de partículas 3D basado en la CPU utilizado para crear una variedad de sistemas y efectos de partículas.

Véase también GPUParticles3D, que proporciona la misma funcionalidad con aceleración por hardware, pero puede que no funcione 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

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)

Métodos

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)

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.

DrawOrder DRAW_ORDER_VIEW_DEPTH = 2

Las partículas se dibujan en orden de profundidad.

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

Utilizar con set_particle_flag() para establecer particle_flag_rotate_y.

ParticleFlags PARTICLE_FLAG_DISABLE_Z = 2

Utiliza con set_particle_flag() para establecer particle_flag_disable_z.

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.

EmissionShape EMISSION_SHAPE_SPHERE_SURFACE = 2

Las partículas se emitirán sobre la superficie de una esfera.

EmissionShape EMISSION_SHAPE_BOX = 3

Se emitirán partículas en el volumen de una caja.

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

Las partículas se emitirán en un anillo o cilindro.

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 🔗

Ángulo máximo.

float angle_min = 0.0 🔗

Ángulo mínimo.

Curve angular_velocity_curve 🔗

La velocidad angular (velocidad de rotación) de cada partícula variará a lo largo de esta Curve durante su vida útil. 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 🔗

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

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 la animación.

float anim_offset_min = 0.0 🔗

Desplazamiento mínimo de la animación.

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.

float anim_speed_min = 0.0 🔗

Velocidad mínima de animación de partículas.

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

Color inicial de cada partícula.

Nota: color multiplica los colores de los vértices de la malla de partículas. Para que tenga un efecto visible en un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo debe ser true. Para un ShaderMaterial, ALBEDO *= COLOR.rgb; debe insertarse en la función fragment() del shader. De lo contrario, color no tendrá ningún efecto visible.

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

Nota: color_initial_ramp multiplica los colores de los vértices de la malla de partículas. Para que tenga un efecto visible en un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo debe ser true. Para un ShaderMaterial, ALBEDO *= COLOR.rgb; debe insertarse en la función fragment() del shader. De lo contrario, color_initial_ramp no tendrá ningún efecto visible.

Gradient color_ramp 🔗

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

Nota: color_ramp multiplica los colores de los vértices de la malla de partículas. Para que tenga un efecto visible en un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo debe ser true. Para un ShaderMaterial, ALBEDO *= COLOR.rgb; debe insertarse en la función fragment() del shader. De lo contrario, color_ramp no tendrá ningún efecto visible.

Curve damping_curve 🔗

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

float damping_max = 0.0 🔗

Damping máximo.

float damping_min = 0.0 🔗

Amortiguación mínima.

Vector3 direction = Vector3(1, 0, 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.

Vector3 emission_box_extents 🔗

  • void set_emission_box_extents(value: Vector3)

  • Vector3 get_emission_box_extents()

La extensión del rectángulo si emission_shape se fija en EMISSION_SHAPE_BOX.

PackedColorArray emission_colors = PackedColorArray() 🔗

Establece los Colors para modular las partículas cuando se utiliza EMISSION_SHAPE_POINTS o EMISSION_SHAPE_DIRECTED_POINTS.

Nota: emission_colors multiplica los colores de los vértices de la malla de partículas. Para que tenga un efecto visible en un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo debe ser true. Para un ShaderMaterial, ALBEDO *= COLOR.rgb; debe insertarse en la función fragment() del shader. De lo contrario, emission_colors no tendrá ningún efecto visible.

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 🔗

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

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

Vector3 emission_ring_axis 🔗

  • void set_emission_ring_axis(value: Vector3)

  • Vector3 get_emission_ring_axis()

El eje del anillo cuando se utiliza el emisor EMISSION_SHAPE_RING.

float emission_ring_cone_angle 🔗

  • void set_emission_ring_cone_angle(value: float)

  • float get_emission_ring_cone_angle()

El ángulo del cono cuando se utiliza el emisor EMISSION_SHAPE_RING. El ángulo predeterminado de 90 grados da como resultado un anillo, mientras que un ángulo de 0 grados da como resultado un cono. Los valores intermedios darán como resultado un anillo donde un extremo es más grande que el otro.

Nota: Dependiendo de emission_ring_height, el ángulo puede ser limitado si se alcanza el extremo del anillo para formar un cono perfecto.

float emission_ring_height 🔗

  • void set_emission_ring_height(value: float)

  • float get_emission_ring_height()

La altura del anillo cuando se utiliza el emisor EMISSION_SHAPE_RING.

float emission_ring_inner_radius 🔗

  • void set_emission_ring_inner_radius(value: float)

  • float get_emission_ring_inner_radius()

El radio interior del anillo cuando se utiliza el emisor EMISSION_SHAPE_RING.

float emission_ring_radius 🔗

  • void set_emission_ring_radius(value: float)

  • float get_emission_ring_radius()

El radio del anillo cuando se utiliza el emisor 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 EmissionShape 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 el sistema de partículas en sí mismo.

float flatness = 0.0 🔗

  • void set_flatness(value: float)

  • float get_flatness()

Cantidad de spread en el plano Y/Z. Un valor de 1 restringe las partículas al plano X/Z.

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.

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

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

float hue_variation_min = 0.0 🔗

Variación mínima de tono.

float initial_velocity_max = 0.0 🔗

Valor máximo de la velocidad inicial.

float initial_velocity_min = 0.0 🔗

Valor mínimo de la velocidad inicial.

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.

float linear_accel_min = 0.0 🔗

Aceleración lineal mínima.

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 CPUParticles3D (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 CPUParticles3D (y sus padres) cuando este se mueva o gire.

Mesh mesh 🔗

  • void set_mesh(value: Mesh)

  • Mesh get_mesh()

La Mesh usada para cada partícula. Si null, las partículas serán esferas.

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 🔗

Velocidad máxima de órbita.

float orbit_velocity_min 🔗

Velocidad mínima de órbita.

bool particle_flag_align_y = false 🔗

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

bool particle_flag_disable_z = false 🔗

Si es true, las partículas no se moverán en el eje Z.

bool particle_flag_rotate_y = false 🔗

Si es true, las partículas giran alrededor del eje Y por angle_min.

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.

float radial_accel_min = 0.0 🔗

Aceleración radial mínima.

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 máxima.

float scale_amount_min = 1.0 🔗

Escala mínima.

Curve scale_curve_x 🔗

  • void set_scale_curve_x(value: Curve)

  • Curve get_scale_curve_x()

Curva para la escala a lo largo de la vida útil, a lo largo del eje X.

Curve scale_curve_y 🔗

  • void set_scale_curve_y(value: Curve)

  • Curve get_scale_curve_y()

Curva para la escala a lo largo de la vida útil, a lo largo del eje Y.

Curve scale_curve_z 🔗

  • void set_scale_curve_z(value: Curve)

  • Curve get_scale_curve_z()

Curva de la escala a lo largo de la vida, a lo largo del eje Z.

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 se establece en true, se pueden especificar tres curvas de escala diferentes, una por eje de escala.

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. Aplicado a los planos X/Z y Y/Z.

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.

float tangential_accel_min = 0.0 🔗

Aceleración tangencial mínima.

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.

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

  • void set_visibility_aabb(value: AABB)

  • AABB get_visibility_aabb()

El AABB que determina la región del nodo que debe estar visible en la pantalla para que el sistema de partículas esté activo.

Aumenta el tamaño del cuadro si las partículas aparecen/desaparecen repentinamente cuando el nodo entra/sale de la pantalla. El AABB puede aumentarse mediante código o con la herramienta del editor Partículas → Generar AABB.

Descripciones de Métodos

AABB capture_aabb() const 🔗

Devuelve el cuadro delimitador alineado con el eje que contiene todas las partículas que están activas en el cuadro actual.

void convert_from_particles(particles: Node) 🔗

Establece las propiedades de este nodo para que coincidan con un nodo GPUParticles3D dado 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.