GPUParticles2D
Hereda: Node2D < CanvasItem < Node < Object
Un emisor de partículas 2D.
Descripción
Nodo de partículas 2D utilizado para crear una variedad de sistemas de partículas y efectos. GPUParticles2D cuenta con un emisor que genera un cierto número de partículas a una velocidad determinada.
Utiliza la propiedad 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.
Las partículas 2D pueden colisionar opcionalmente con LightOccluder2D, pero no colisionan con los nodos PhysicsBody2D.
Tutoriales
Propiedades
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Métodos
capture_rect() const |
|
void |
convert_from_particles(particles: Node) |
void |
emit_particle(xform: Transform2D, velocity: Vector2, color: Color, custom: Color, flags: int) |
void |
request_particles_process(process_time: float) |
void |
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.
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.
Descripciones de Propiedades
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.
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 = 1.0 🔗
Multiplicador del radio de colisión de la partícula. 1.0 corresponde al tamaño del sprite. 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.
Orden de dibujado de partículas.
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.
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.
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í.
Si es true, resulta en un cálculo delta fraccionario que tiene un efecto de visualización de partículas más suave.
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.
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.
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.
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 GPUParticles2D (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 GPUParticles2D (y sus padres) cuando se mueve o gira.
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.
El sistema de partículas comienza como si ya hubiera funcionado durante esta cantidad de segundos.
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 para procesar partículas. Puede ser un ParticleProcessMaterial o un ShaderMaterial.
Proporción de aleatoriedad de la vida útil de las emisiones.
Establece la semilla aleatoria utilizada por el sistema de partículas. Solo es efectivo si use_fixed_seed es true.
El sistema de partículas está funcionando a una velocidad de escalada. Un valor de 0 puede ser usado para pausar las partículas.
NodePath sub_emitter = NodePath("") 🔗
Ruta a otro nodo GPUParticles2D que se usará 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 GPUParticles2D de destino ya no emitirá partículas por sí solo.
Particle texture. If null, particles will be squares with a size of 1×1 pixels.
Note: To use a flipbook texture, assign a new CanvasItemMaterial to the GPUParticles2D's CanvasItem.material property, then enable CanvasItemMaterial.particles_animation and set CanvasItemMaterial.particles_anim_h_frames, CanvasItemMaterial.particles_anim_v_frames, and CanvasItemMaterial.particles_anim_loop to match the flipbook texture.
Si es true, habilita los rastros de partículas utilizando un sistema de skinning de malla.
Nota: A diferencia de GPUParticles3D, el número de secciones de rastro y subdivisiones se establece con las propiedades trail_sections y trail_section_subdivisions.
La cantidad de tiempo que la estela de la partícula debe representar (en segundos). Solo es efectivo si trail_enabled es true.
int trail_section_subdivisions = 4 🔗
El número de subdivisiones a usar para el renderizado del rastro de la partícula. Los valores más altos pueden resultar en curvas de rastro más suaves, a costa del rendimiento debido a la mayor complejidad de la malla. Véase también trail_sections. Solo es efectivo si trail_enabled es true.
El número de secciones a usar para el renderizado del rastro de la partícula. Los valores más altos pueden resultar en curvas de rastro más suaves, a costa del rendimiento debido a la mayor complejidad de la malla. Véase también trail_section_subdivisions. Solo es efectivo si trail_enabled es true.
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.
Rect2 visibility_rect = Rect2(-100, -100, 200, 200) 🔗
El Rect2 que determina la región del nodo que necesita estar visible en la pantalla para que el sistema de partículas esté activo.
Aumenta el Rect si las partículas aparecen/desaparecen repentinamente cuando el nodo entra/sale de la pantalla. El Rect2 puede aumentarse mediante código o con la herramienta del editor Partículas → Generar Rect de Visibilidad.
Descripciones de Métodos
Devuelve un rectángulo que contiene las posiciones de todas las partículas existentes.
Nota: Cuando se utiliza el renderizado en hilos, este método sincroniza el hilo de renderizado. Llamarlo a menudo puede tener un impacto negativo en el rendimiento.
void convert_from_particles(particles: Node) 🔗
Establece las propiedades de este nodo para que coincidan con las de un nodo CPUParticles2D dado.
void emit_particle(xform: Transform2D, velocity: Vector2, 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.
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.