GPUParticles3D

Hereda: GeometryInstance3D < VisualInstance3D < Node3D < Node < Object

Un emisor de partículas 3D.

Descripción

Nodo de partículas 3D utilizado para crear una variedad de sistemas y efectos de partículas. GPUParticles3D cuenta con un emisor que genera un número de partículas a una velocidad determinada.

Usa process_material para añadir un ParticleProcessMaterial para configurar la apariencia y el comportamiento de las partículas. Alternativamente, puedes añadir un ShaderMaterial que se aplicará a todas las partículas.

Tutoriales

Propiedades

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

bool

use_fixed_seed

false

AABB

visibility_aabb

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

Métodos

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)

void

restart(keep_seed: bool = false)

void

set_draw_pass_mesh(pass: int, mesh: Mesh)

Señales

finished() 🔗

Emitida cuando todas las partículas activas han terminado de procesarse. Para reiniciar inmediatamente el ciclo de emisión, llama a restart().

Esta señal nunca se emite cuando one_shot está deshabilitado, ya que las partículas se emitirán y procesarán continuamente.

Nota: Para los emisores one_shot, debido a que las partículas se calculan en la GPU, puede haber un breve período después de recibir la señal durante el cual establecer emitting en true no reiniciará el ciclo de emisión. Este retraso se evita llamando en su lugar a restart().

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

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

DrawOrder DRAW_ORDER_VIEW_DEPTH = 3

Las partículas se dibujan en orden de profundidad.

enum EmitFlags: 🔗

EmitFlags EMIT_FLAG_POSITION = 1

La partícula comienza en la posición especificada.

EmitFlags EMIT_FLAG_ROTATION_SCALE = 2

La partícula comienza con la rotación y la escala especificadas.

EmitFlags EMIT_FLAG_VELOCITY = 4

La partícula comienza con el vector de velocidad especificado, que define la dirección y la velocidad de emisión.

EmitFlags EMIT_FLAG_COLOR = 8

La partícula comienza con el color especificado.

EmitFlags EMIT_FLAG_CUSTOM = 16

La partícula comienza con los datos CUSTOM especificados.

enum TransformAlign: 🔗

TransformAlign TRANSFORM_ALIGN_DISABLED = 0

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

TransformAlign TRANSFORM_ALIGN_Z_BILLBOARD = 1

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

TransformAlign TRANSFORM_ALIGN_Y_TO_VELOCITY = 2

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

TransformAlign TRANSFORM_ALIGN_Z_BILLBOARD_Y_TO_VELOCITY = 3

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

Constantes

MAX_DRAW_PASSES = 4 🔗

Número máximo de pases de dibujado soportados.

Descripciones de Propiedades

int amount = 8 🔗

  • void set_amount(value: int)

  • int get_amount()

El número de partículas a emitir en un ciclo de emisión. La tasa de emisión efectiva es de (amount * amount_ratio) / lifetime partículas por segundo. Valores más altos aumentarán los requisitos de la GPU, incluso si no todas las partículas son visibles en un momento dado o si se reduce amount_ratio.

Nota: Cambiar este valor hará que el sistema de partículas se reinicie. Para evitar esto, cambia amount_ratio en su lugar.

float amount_ratio = 1.0 🔗

  • void set_amount_ratio(value: float)

  • float get_amount_ratio()

La relación de partículas que deberían emitirse realmente. Si se establece a un valor menor que 1.0, esto establecerá la cantidad de partículas emitidas a lo largo de la vida útil a amount * amount_ratio. A diferencia de cambiar amount, cambiar amount_ratio mientras se emite no afecta a las partículas ya emitidas y no hace que el sistema de partículas se reinicie. amount_ratio se puede utilizar para crear efectos que hagan que el número de partículas emitidas varíe con el tiempo.

Nota: Reducir el amount_ratio no tiene ningún beneficio de rendimiento, ya que los recursos deben ser asignados y procesados para la amount total de partículas independientemente del amount_ratio. Si no tienes la intención de cambiar el número de partículas emitidas mientras las partículas están emitiendo, asegúrate de que amount_ratio esté establecido en 1 y cambia amount a tu gusto en su lugar.

float collision_base_size = 0.01 🔗

  • void set_collision_base_size(value: float)

  • float get_collision_base_size()

El diámetro base para la colisión de partículas en metros. Si las partículas parecen hundirse en el suelo al colisionar, aumenta este valor. Si las partículas parecen flotar al colisionar, disminuye este valor. Solo es efectivo si ParticleProcessMaterial.collision_mode es ParticleProcessMaterial.COLLISION_RIGID o ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT.

Nota: Las partículas siempre tienen una forma de colisión esférica.

DrawOrder draw_order = 0 🔗

Orden de dibujado de las partículas.

Nota: DRAW_ORDER_INDEX es la única opción que admite vectores de movimiento para efectos como TAA. Se sugiere usar este orden de dibujado si las partículas son opacas para corregir artefactos de fantasma.

Mesh draw_pass_1 🔗

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

  • Mesh get_draw_pass_mesh(pass: int) const

Mesh que se dibuja para el primer pase de dibujado.

Mesh draw_pass_2 🔗

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

  • Mesh get_draw_pass_mesh(pass: int) const

Mesh que se dibuja para el segundo pase de dibujado.

Mesh draw_pass_3 🔗

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

  • Mesh get_draw_pass_mesh(pass: int) const

Mesh que se dibuja para el tercer pase de dibujado.

Mesh draw_pass_4 🔗

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

  • Mesh get_draw_pass_mesh(pass: int) const

Mesh que se dibuja para el cuarto pase de dibujado.

int draw_passes = 1 🔗

  • void set_draw_passes(value: int)

  • int get_draw_passes()

El número de pases de dibujado cuando se renderizan las partículas.

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

Si es true, se están emitiendo partículas. emitting se puede utilizar para iniciar y detener la emisión de partículas. Sin embargo, si one_shot es true, establecer emitting en true no reiniciará el ciclo de emisión a menos que todas las partículas activas hayan terminado de procesarse. Utiliza la señal finished para que se te notifique una vez que todas las partículas activas terminen de procesarse.

Nota: Para los emisores one_shot, debido a que las partículas se computan en la GPU, puede haber un breve período después de recibir la señal finished durante el cual establecer esto en true no reiniciará el ciclo de emisión.

Consejo: Si tu emisor one_shot necesita reiniciar inmediatamente la emisión de partículas una vez que se recibe la señal finished, considera llamar a restart() en lugar de establecer emitting.

float explosiveness = 0.0 🔗

  • void set_explosiveness_ratio(value: float)

  • float get_explosiveness_ratio()

Ratio de tiempo entre cada emisión. Si 0, las partículas se emiten continuamente. Si 1, todas las partículas se emiten simultáneamente.

int fixed_fps = 30 🔗

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

float interp_to_end = 0.0 🔗

  • void set_interp_to_end(value: float)

  • float get_interp_to_end()

Hace que todas las partículas en este nodo se interpolen hacia el final de su vida útil.

Nota: Esto solo funciona cuando se usa con un ParticleProcessMaterial. Debe implementarse manualmente para shaders de proceso personalizados.

bool interpolate = true 🔗

  • void set_interpolate(value: bool)

  • bool get_interpolate()

Habilita la interpolación de partículas, lo que hace que el movimiento de las partículas sea más suave cuando su fixed_fps es menor que la frecuencia de actualización de la pantalla.

float lifetime = 1.0 🔗

  • void set_lifetime(value: float)

  • float get_lifetime()

La cantidad de tiempo que cada partícula existirá (en segundos). La tasa de emisión efectiva es (amount * amount_ratio) / lifetime partículas por segundo.

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 GPUParticles3D (y sus padres) cuando se mueve o gira. Si es false, las partículas usan coordenadas globales; no se moverán ni rotarán junto con el nodo GPUParticles3D (y sus padres) cuando se mueve o gira.

bool one_shot = false 🔗

  • void set_one_shot(value: bool)

  • bool get_one_shot()

Si es true, solo se emitirá el número de partículas igual a amount.

float preprocess = 0.0 🔗

  • void set_pre_process_time(value: float)

  • float get_pre_process_time()

Cantidad de tiempo para preprocesar las partículas antes de que comience la animación. Permite iniciar la animación algún tiempo después de que las partículas hayan comenzado a emitirse.

Nota: Esto puede ser muy costoso si se establece en un número alto, ya que requiere ejecutar el shader de partículas varias veces igual a fixed_fps (o 30, si fixed_fps es 0) por cada segundo. En casos extremos, incluso puede provocar un fallo de la GPU debido al volumen de trabajo realizado en un solo fotograma.

Material process_material 🔗

Material para procesar partículas. Puede ser un ParticleProcessMaterial o un ShaderMaterial.

float randomness = 0.0 🔗

  • void set_randomness_ratio(value: float)

  • float get_randomness_ratio()

Ratio de aleatoriedad de las emisiones.

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

Relación de escala de velocidad. Un valor de 0 puede ser usado para pausar las partículas.

NodePath sub_emitter = NodePath("") 🔗

Ruta a otro nodo GPUParticles3D que se utilizará como subemisor (ver ParticleProcessMaterial.sub_emitter_mode). Los subemisores se pueden utilizar para lograr efectos tales como fuegos artificiales, chispas en la colisión, burbujas que estallan en gotas de agua, y más.

Nota: Cuando sub_emitter está establecido, el nodo GPUParticles3D de destino ya no emitirá partículas por sí solo.

bool trail_enabled = false 🔗

  • void set_trail_enabled(value: bool)

  • bool is_trail_enabled()

Si es true, habilita los rastros de partículas utilizando un sistema de skinning de malla. Diseñado para funcionar con RibbonTrailMesh y TubeTrailMesh.

Nota: BaseMaterial3D.use_particle_trails también debe estar habilitado en el material de la malla de partículas. De lo contrario, establecer trail_enabled en true no tendrá ningún efecto.

Nota: A diferencia de GPUParticles2D, el número de secciones y subdivisiones del rastro se establece en las propiedades de RibbonTrailMesh o TubeTrailMesh.

float trail_lifetime = 0.3 🔗

  • void set_trail_lifetime(value: float)

  • float get_trail_lifetime()

La cantidad de tiempo que la estela de la partícula debe representar (en segundos). Solo es efectivo si trail_enabled es true.

TransformAlign transform_align = 0 🔗

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

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

  • 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. Se añade GeometryInstance3D.extra_cull_margin en cada uno de los ejes del AABB. Las colisiones y la atracción de partículas solo ocurrirán dentro de esta área.

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

Nota: visibility_aabb se sobrescribe mediante GeometryInstance3D.custom_aabb si esa propiedad se establece en un valor no predeterminado.

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

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

Emite una sola partícula. Que se apliquen xform, velocity, color y custom depende del valor de flags. Véase EmitFlags.

El ParticleProcessMaterial por defecto sobrescribirá color y usará el contenido de custom como (rotación, edad, animación, tiempo de vida).

Nota: emit_particle() solo es compatible con los métodos de renderizado Forward+ y Mobile, no con Compatibility.

Mesh get_draw_pass_mesh(pass: int) const 🔗

Devuelve el Mesh que se dibuja en el índice pass.

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 ciclo de emisión de partículas, limpiando las partículas existentes. Para evitar que las partículas desaparezcan de la ventana gráfica, espera a la señal finished antes de llamar.

Nota: La señal finished solo es emitida por emisores one_shot.

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

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

Establece el Mesh que se dibuja en el índice pass.