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...
ParticleProcessMaterial
Hereda: Material < Resource < RefCounted < Object
Mantiene una configuración de partículas para los nodos GPUParticles2D o GPUParticles3D.
Descripción
ParticleProcessMaterial defines particle properties and behavior. It is used in the process_material of the GPUParticles2D and GPUParticles3D nodes. Some of this material's properties are applied to each particle when emitted, while others can have a CurveTexture or a GradientTexture1D applied to vary numerical or color values over the lifetime of the particle.
Propiedades
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Métodos
get_param_max(param: Parameter) const |
|
get_param_min(param: Parameter) const |
|
get_param_texture(param: Parameter) const |
|
get_particle_flag(particle_flag: ParticleFlags) const |
|
void |
|
void |
set_param_max(param: Parameter, value: float) |
void |
set_param_min(param: Parameter, value: float) |
void |
set_param_texture(param: Parameter, texture: Texture2D) |
void |
set_particle_flag(particle_flag: ParticleFlags, enable: bool) |
Señales
emission_shape_changed() 🔗
Emitida cuando la forma de emisión de este material se cambia de alguna manera. Esto incluye cambios en emission_shape, emission_shape_scale o emission_sphere_radius, y cualquier otra propiedad que afecte el desplazamiento, el tamaño, la escala o la orientación de la forma de emisión.
Nota: Esta señal solo se emite dentro del editor por razones de rendimiento.
Enumeraciones
enum Parameter: 🔗
Parameter PARAM_INITIAL_LINEAR_VELOCITY = 0
Utilízalo con set_param_min(), set_param_max(), y set_param_texture() para establecer las propiedades iniciales de la velocidad.
Parameter PARAM_ANGULAR_VELOCITY = 1
Utilízalo con set_param_min(), set_param_max(), y set_param_texture() para establecer las propiedades de la velocidad angular.
Parameter PARAM_ORBIT_VELOCITY = 2
Utilízalo con set_param_min(), set_param_max(), y set_param_texture() para establecer las propiedades de la velocidad orbital.
Parameter PARAM_LINEAR_ACCEL = 3
Utilízalo con set_param_min(), set_param_max(), y set_param_texture() para establecer las propiedades de la aceleración lineal.
Parameter PARAM_RADIAL_ACCEL = 4
Utilízalo con set_param_min(), set_param_max(), y set_param_texture() 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_texture() para establecer las propiedades de la aceleración tangencial.
Parameter PARAM_DAMPING = 6
Utilízalo con set_param_min(), set_param_max(), y set_param_texture() para establecer las propiedades de amortiguación.
Parameter PARAM_ANGLE = 7
Utilízalo con set_param_min(), set_param_max(), y set_param_texture() para establecer las propiedades de los ángulos.
Parameter PARAM_SCALE = 8
Utilízalo con set_param_min(), set_param_max(), y set_param_texture() para establecer las propiedades de la escala.
Parameter PARAM_HUE_VARIATION = 9
Utilízalo con set_param_min(), set_param_max(), y set_param_texture() para establecer las propiedades de la variación del tono.
Parameter PARAM_ANIM_SPEED = 10
Utiliza set_param_min(), set_param_max() y set_param_texture() para establecer las propiedades de la velocidad de animación.
Parameter PARAM_ANIM_OFFSET = 11
Utiliza set_param_min(), set_param_max() y set_param_texture() para establecer las propiedades del desplazamiento de la animación.
Parameter PARAM_RADIAL_VELOCITY = 15
Utiliza set_param_min(), set_param_max() y set_param_texture() para establecer las propiedades de la velocidad radial.
Parameter PARAM_DIRECTIONAL_VELOCITY = 16
Utiliza set_param_min(), set_param_max() y set_param_texture() para establecer las propiedades de la velocidad direccional.
Parameter PARAM_SCALE_OVER_VELOCITY = 17
Utiliza set_param_min(), set_param_max() y set_param_texture() para establecer las propiedades de la escala sobre la velocidad.
Parameter PARAM_MAX = 18
Representa el tamaño del enumerado Parameter.
Parameter PARAM_TURB_VEL_INFLUENCE = 13
Utiliza set_param_min() y set_param_max() para establecer la influencia mínima y máxima de la turbulencia en la velocidad de cada partícula.
Parameter PARAM_TURB_INIT_DISPLACEMENT = 14
Utilízalo con set_param_min() y set_param_max() para establecer el desplazamiento mínimo y máximo de turbulencia de la posición de aparición de las partículas.
Parameter PARAM_TURB_INFLUENCE_OVER_LIFE = 12
Utiliza set_param_texture() para establecer la influencia de la turbulencia sobre la vida útil de las partículas.
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_DAMPING_AS_FRICTION = 3
There is currently no description for this enum. Please help us by contributing one!
ParticleFlags PARTICLE_FLAG_INHERIT_EMITTER_SCALE = 4
There is currently no description for this enum. Please help us by contributing one!
ParticleFlags PARTICLE_FLAG_MAX = 5
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 determinada por el muestreo de un punto aleatorio en la emission_point_texture. El color de las partículas será modulado por emission_color_texture.
EmissionShape EMISSION_SHAPE_DIRECTED_POINTS = 5
Las partículas se emitirán en una posición determinada por el muestreo de un punto aleatorio en la emission_point_texture. La velocidad y la rotación de las partículas se fijarán en base a emission_normal_texture. El color de las partículas será modulado por emission_color_texture.
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.
enum SubEmitterMode: 🔗
SubEmitterMode SUB_EMITTER_DISABLED = 0
The subemitter is disabled.
SubEmitterMode SUB_EMITTER_CONSTANT = 1
The submitter is emitted on the constant interval defined by sub_emitter_frequency.
SubEmitterMode SUB_EMITTER_AT_END = 2
The subemitter is emitted at the end of the particle's lifetime.
SubEmitterMode SUB_EMITTER_AT_COLLISION = 3
The subemitter is emitted when the particle collides.
SubEmitterMode SUB_EMITTER_AT_START = 4
The subemitter is emitted when the particle spawns.
SubEmitterMode SUB_EMITTER_MAX = 5
Representa el tamaño del enum SubEmitterMode.
enum CollisionMode: 🔗
CollisionMode COLLISION_DISABLED = 0
Sin colisión para las partículas. Las partículas atravesarán los nodos GPUParticlesCollision3D.
CollisionMode COLLISION_RIGID = 1
Colisión al estilo RigidBody3D para partículas usando nodos GPUParticlesCollision3D.
CollisionMode COLLISION_HIDE_ON_CONTACT = 2
Oculta las partículas instantáneamente al colisionar con un nodo GPUParticlesCollision3D. Esto se puede combinar con un subemisor que utilice el modo de colisión COLLISION_RIGID para "reemplazar" la partícula principal con el subemisor al impactar.
CollisionMode COLLISION_MAX = 3
Representa el tamaño del enum CollisionMode.
Descripciones de Propiedades
The alpha value of each particle's color will be multiplied by this CurveTexture over its lifetime.
Note: alpha_curve multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo must be true. For a ShaderMaterial, ALPHA *= COLOR.a; must be inserted in the shader's fragment() function. Otherwise, alpha_curve will have no visible effect.
La rotación de cada partícula será animada a lo largo de esta CurveTexture.
Rotación inicial aplicada a cada partícula, en grados.
Solo se aplica cuando particle_flag_disable_z o particle_flag_rotate_y son true o el BaseMaterial3D que se usa para dibujar la partícula está usando BaseMaterial3D.BILLBOARD_PARTICLES.
Equivalente mínimo de angle_max.
Texture2D angular_velocity_curve 🔗
Each particle's angular velocity (rotation speed) will vary along this CurveTexture over its lifetime.
float angular_velocity_max = 0.0 🔗
Maximum initial angular velocity (rotation speed) applied to each particle in degrees per second.
Only applied when particle_flag_disable_z or particle_flag_rotate_y are true or the BaseMaterial3D being used to draw the particle is using BaseMaterial3D.BILLBOARD_PARTICLES.
float angular_velocity_min = 0.0 🔗
Equivalente mínimo de angular_velocity_max.
El desplazamiento de la animación de cada partícula variará a lo largo de esta CurveTexture.
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.
Equivalente mínimo de anim_offset_max.
La velocidad de animación de cada partícula variará a lo largo de esta CurveTexture.
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.
Equivalente mínimo de anim_speed_max.
bool attractor_interaction_enabled = true 🔗
If true, interaction with particle attractors is enabled. In 3D, attraction only occurs within the area defined by the GPUParticles3D node's GPUParticles3D.visibility_aabb.
The particles' bounciness. Values range from 0 (no bounce) to 1 (full bounciness). Only effective if collision_mode is COLLISION_RIGID.
The particles' friction. Values range from 0 (frictionless) to 1 (maximum friction). Only effective if collision_mode is COLLISION_RIGID.
CollisionMode collision_mode = 0 🔗
void set_collision_mode(value: CollisionMode)
CollisionMode get_collision_mode()
The particles' collision mode.
Note: 3D Particles can only collide with GPUParticlesCollision3D nodes, not PhysicsBody3D nodes. To make particles collide with various objects, you can add GPUParticlesCollision3D nodes as children of PhysicsBody3D nodes. In 3D, collisions only occur within the area defined by the GPUParticles3D node's GPUParticles3D.visibility_aabb.
Note: 2D Particles can only collide with LightOccluder2D nodes, not PhysicsBody2D nodes.
bool collision_use_scale = false 🔗
If true, GPUParticles3D.collision_base_size is multiplied by the particle's effective scale (see scale_min, scale_max, scale_curve, and scale_over_velocity_curve).
Color color = Color(1, 1, 1, 1) 🔗
Each particle's initial color. If the GPUParticles2D's texture is defined, it will be multiplied by this color.
Note: color multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo must be true. For a ShaderMaterial, ALBEDO *= COLOR.rgb; must be inserted in the shader's fragment() function. Otherwise, color will have no visible effect.
Texture2D color_initial_ramp 🔗
Each particle's initial color will vary along this GradientTexture1D (multiplied with color).
Note: color_initial_ramp multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo must be true. For a ShaderMaterial, ALBEDO *= COLOR.rgb; must be inserted in the shader's fragment() function. Otherwise, color_initial_ramp will have no visible effect.
Each particle's color will vary along this GradientTexture1D over its lifetime (multiplied with color).
Note: color_ramp multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo must be true. For a ShaderMaterial, ALBEDO *= COLOR.rgb; must be inserted in the shader's fragment() function. Otherwise, color_ramp will have no visible effect.
La amortiguación variará a lo largo de esta CurveTexture.
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.
Equivalente mínimo de damping_max.
Vector3 direction = Vector3(1, 0, 0) 🔗
Vector unitario que especifica la dirección de emisión de las partículas.
Texture2D directional_velocity_curve 🔗
A curve that specifies the velocity along each of the axes of the particle system along its lifetime.
Note: Animated velocities will not be affected by damping, use velocity_limit_curve instead.
float directional_velocity_max 🔗
Maximum directional velocity value, which is multiplied by directional_velocity_curve.
Note: Animated velocities will not be affected by damping, use velocity_limit_curve instead.
float directional_velocity_min 🔗
Minimum directional velocity value, which is multiplied by directional_velocity_curve.
Note: Animated velocities will not be affected by damping, use velocity_limit_curve instead.
Vector3 emission_box_extents 🔗
The box's extents if emission_shape is set to EMISSION_SHAPE_BOX.
Note: emission_box_extents starts from the center point and applies the X, Y, and Z values in both directions. The size is twice the area of the extents.
Texture2D emission_color_texture 🔗
Particle color will be modulated by color determined by sampling this texture at the same point as the emission_point_texture.
Note: emission_color_texture multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo must be true. For a ShaderMaterial, ALBEDO *= COLOR.rgb; must be inserted in the shader's fragment() function. Otherwise, emission_color_texture will have no visible effect.
El color de cada partícula se multiplicará por esta CurveTexture a lo largo de su vida útil.
Nota: emission_curve multiplica los colores de los vértices de la malla de la partícula. 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 sombreador. De lo contrario, emission_curve no tendrá ningún efecto visible.
Texture2D emission_normal_texture 🔗
La velocidad y la rotación de las partículas se fijarán mediante el muestreo de esta textura en el mismo punto que la emission_point_texture. Se utiliza sólo en EMISSION_SHAPE_DIRECTED_POINTS. Se puede crear automáticamente a partir de la malla o del nodo seleccionando "Crear puntos de emisión a partir de la malla o del nodo" en la herramienta "Partículas" de la barra de herramientas.
El número de puntos de emisión si emission_shape se establece en EMISSION_SHAPE_POINTS o EMISSION_SHAPE_DIRECTED_POINTS.
Texture2D emission_point_texture 🔗
Las partículas se emitirán en posiciones determinadas por el muestreo de esta textura en una posición aleatoria. Se utiliza con EMISSION_SHAPE_POINTS y EMISSION_SHAPE_DIRECTED_POINTS. Se puede crear automáticamente a partir de la malla o del nodo seleccionando "Crear puntos de emisión a partir de la malla o del nodo" en la herramienta "Partículas" de la barra de herramientas.
El eje del anillo cuando se utiliza el emisor EMISSION_SHAPE_RING.
float 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.
La altura del anillo cuando se utiliza el emisor EMISSION_SHAPE_RING.
float emission_ring_inner_radius 🔗
El radio interior del anillo cuando se utiliza el emisor EMISSION_SHAPE_RING.
El radio del anillo cuando se utiliza el emisor EMISSION_SHAPE_RING.
EmissionShape emission_shape = 0 🔗
void set_emission_shape(value: EmissionShape)
EmissionShape get_emission_shape()
Se emitirán partículas dentro de esta región.
Vector3 emission_shape_offset = Vector3(0, 0, 0) 🔗
El desplazamiento de emission_shape, en espacio local.
Vector3 emission_shape_scale = Vector3(1, 1, 1) 🔗
La escala de emission_shape, en espacio local.
float emission_sphere_radius 🔗
El radio de la esfera si emission_shape se fija en EMISSION_SHAPE_SPHERE.
Cantidad de spread a lo largo del eje Y.
Vector3 gravity = Vector3(0, -9.8, 0) 🔗
La gravedad aplicada a cada partícula.
Texture2D hue_variation_curve 🔗
El tono de cada partícula variará a lo largo de esta CurveTexture.
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 inherit_velocity_ratio = 0.0 🔗
Porcentaje de la velocidad de las respectivas GPUParticles2D o GPUParticles3D heredada por cada partícula al generarse.
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_randomness = 0.0 🔗
Relación de aleatoriedad de la vida útil de la partícula. La ecuación para la vida útil de una partícula es lifetime * (1.0 - randf() * lifetime_randomness). Por ejemplo, un lifetime_randomness de 0.4 escala la vida útil entre 0.6 y 1.0 de su valor original.
Texture2D linear_accel_curve 🔗
La aceleración lineal de cada partícula variará a lo largo de esta CurveTexture.
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.
Texture2D orbit_velocity_curve 🔗
La velocidad orbital de cada partícula variará a lo largo de esta CurveTexture.
Nota: Para la velocidad orbital 3D, usa una CurveXYZTexture.
Nota: Las velocidades animadas no se verán afectadas por la amortiguación, usa velocity_limit_curve en su lugar.
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.
Nota: Las velocidades animadas no se verán afectadas por la amortiguación, usa velocity_limit_curve en su lugar.
float orbit_velocity_min = 0.0 🔗
Mínimo equivalente de orbit_velocity_max.
Nota: Las velocidades animadas no se verán afectadas por la amortiguación, usa velocity_limit_curve en su lugar.
bool particle_flag_align_y = false 🔗
void set_particle_flag(particle_flag: ParticleFlags, enable: bool)
bool get_particle_flag(particle_flag: ParticleFlags) const
Alinea el eje Y de la partícula con la dirección de su velocidad.
bool particle_flag_damping_as_friction = false 🔗
void set_particle_flag(particle_flag: ParticleFlags, enable: bool)
bool get_particle_flag(particle_flag: ParticleFlags) const
Cambia el comportamiento de las propiedades de amortiguación de una desaceleración lineal a una desaceleración basada en el porcentaje de velocidad.
bool particle_flag_disable_z = false 🔗
void set_particle_flag(particle_flag: ParticleFlags, enable: bool)
bool get_particle_flag(particle_flag: ParticleFlags) const
Si es true, las partículas no se moverán en el eje z.
bool particle_flag_inherit_emitter_scale = false 🔗
void set_particle_flag(particle_flag: ParticleFlags, enable: bool)
bool get_particle_flag(particle_flag: ParticleFlags) const
If true, particles will inherit the scale of the emitter.
Note: This has no effect when GPUParticles3D.local_coords is true, since particles in local space are already affected by the emitter's scale.
bool particle_flag_rotate_y = false 🔗
void set_particle_flag(particle_flag: ParticleFlags, enable: bool)
bool get_particle_flag(particle_flag: ParticleFlags) const
Si es true, las partículas giran alrededor del eje Y por angle_min.
Texture2D radial_accel_curve 🔗
La aceleración radial de cada partícula variará a lo largo de esta CurveTexture.
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.
Texture2D radial_velocity_curve 🔗
Una CurveTexture que define la velocidad a lo largo de la vida útil de la partícula, alejándose (o acercándose) del velocity_pivot.
Nota: Las velocidades animadas no se verán afectadas por la amortiguación, usa velocity_limit_curve en su lugar.
float radial_velocity_max = 0.0 🔗
Velocidad radial máxima aplicada a cada partícula. Hace que las partículas se alejen del velocity_pivot, o se acerquen a él si es negativa.
Nota: Las velocidades animadas no se verán afectadas por la amortiguación, usa velocity_limit_curve en su lugar.
float radial_velocity_min = 0.0 🔗
Velocidad radial mínima aplicada a cada partícula. Hace que las partículas se alejen del velocity_pivot, o se acerquen a él si es negativa.
Nota: Las velocidades animadas no se verán afectadas por la amortiguación, usa velocity_limit_curve en su lugar.
The maximum 3D orientation, in degrees. Works only in 3D and if use_rotation_3d is enabled.
The minimum 3D orientation, in degrees. Works only in 3D and if use_rotation_3d is enabled.
Texture2D rotation_velocity_3d_curve 🔗
Rotation velocity curve over lifetime, per-axis. Enable use_rotation_velocity_3d to use this.
Vector3 rotation_velocity_3d_max 🔗
Maximum 3D rotation velocity on the particle's local axis. Enable use_rotation_velocity_3d to use this.
Vector3 rotation_velocity_3d_min 🔗
Minimum 3D rotation velocity on the particle's local axis. Enable use_rotation_velocity_3d to use this.
The maximum value of the random scale vector for each particle.
Works only if use_scale_3d is enabled.
The minimum value of the random scale vector for each particle.
Works only if use_scale_3d is enabled.
La escala de cada partícula variará a lo largo de esta CurveTexture durante su vida útil. Si se proporciona una CurveXYZTexture en su lugar, la escala se separará por eje.
Escala inicial máxima aplicada a cada partícula.
Equivalente mínimo de scale_max.
Texture2D scale_over_velocity_curve 🔗
Ya sea una CurveTexture o una CurveXYZTexture que escala cada partícula en función de su velocidad.
float scale_over_velocity_max = 0.0 🔗
Valor máximo de referencia de la velocidad para scale_over_velocity_curve.
scale_over_velocity_curve se interpolará entre scale_over_velocity_min y scale_over_velocity_max.
float scale_over_velocity_min = 0.0 🔗
Valor mínimo de referencia de la velocidad para scale_over_velocity_curve.
scale_over_velocity_curve se interpolará entre scale_over_velocity_min y scale_over_velocity_max.
La dirección inicial de cada partícula va desde +spread hasta -spread grados.
int sub_emitter_amount_at_collision 🔗
La cantidad de partículas que se generarán desde el nodo subemisor cuando ocurre una colisión. Cuando se combina con COLLISION_HIDE_ON_CONTACT en el material de partículas principal, esto se puede usar para lograr efectos como gotas de lluvia golpeando el suelo.
Nota: Este valor no debe exceder GPUParticles2D.amount o GPUParticles3D.amount definido en el nodo subemisor (no en el nodo principal), en relación con la vida útil de la partícula del subemisor. Si se excede el número de partículas, no se generarán nuevas partículas desde el subemisor hasta que hayan expirado suficientes partículas.
int sub_emitter_amount_at_end 🔗
La cantidad de partículas que se generarán desde el nodo subemisor cuando la partícula expira.
Nota: Este valor no debe exceder GPUParticles2D.amount o GPUParticles3D.amount definido en el nodo subemisor (no en el nodo principal), en relación con la vida útil de la partícula del subemisor. Si se excede el número de partículas, no se generarán nuevas partículas desde el subemisor hasta que hayan expirado suficientes partículas.
int sub_emitter_amount_at_start 🔗
La cantidad de partículas a generar desde el nodo subemisor cuando la partícula se genera.
Nota: Este valor no debe exceder GPUParticles2D.amount o GPUParticles3D.amount definidos en el nodo subemisor (no el nodo principal), en relación con la vida útil de la partícula del subemisor. Si se excede el número de partículas, no se generarán nuevas partículas desde el subemisor hasta que suficientes partículas hayan expirado.
La frecuencia a la que las partículas deben ser emitidas desde el nodo subemisor. Se generará una partícula cada sub_emitter_frequency segundos.
Nota: Este valor no debe exceder GPUParticles2D.amount o GPUParticles3D.amount definidos en el nodo subemisor (no el nodo principal), en relación con la vida útil de la partícula del subemisor. Si se excede el número de partículas, no se generarán nuevas partículas desde el subemisor hasta que suficientes partículas hayan expirado.
bool sub_emitter_keep_velocity = false 🔗
Si es true, el subemisor hereda la velocidad de la partícula principal cuando se genera.
SubEmitterMode sub_emitter_mode = 0 🔗
void set_sub_emitter_mode(value: SubEmitterMode)
SubEmitterMode get_sub_emitter_mode()
El modo de subemisor de partículas (véase GPUParticles2D.sub_emitter y GPUParticles3D.sub_emitter).
Texture2D tangential_accel_curve 🔗
La aceleración tangencial de cada partícula variará a lo largo de esta CurveTexture.
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.
bool turbulence_enabled = false 🔗
Si es true, habilita la turbulencia para el sistema de partículas. La turbulencia se puede usar para variar el movimiento de las partículas según su posición (basado en un patrón de ruido 3D). En 3D, GPUParticlesAttractorVectorField3D con NoiseTexture3D se puede usar como una alternativa a la turbulencia que funciona en el espacio del mundo y con múltiples sistemas de partículas reaccionando de la misma manera.
Nota: Habilitar la turbulencia tiene un alto costo de rendimiento en la GPU. Habilita la turbulencia solo en unos pocos sistemas de partículas a la vez como máximo, y considera deshabilitarla cuando te dirijas a plataformas móviles/web.
float turbulence_influence_max = 0.1 🔗
Influencia máxima de turbulencia en cada partícula.
La cantidad real de influencia de turbulencia en cada partícula se calcula como un valor aleatorio entre turbulence_influence_min y turbulence_influence_max y se multiplica por la cantidad de influencia de turbulencia de turbulence_influence_over_life.
float turbulence_influence_min = 0.1 🔗
Influencia mínima de turbulencia en cada partícula.
La cantidad real de influencia de turbulencia en cada partícula se calcula como un valor aleatorio entre turbulence_influence_min y turbulence_influence_max y se multiplica por la cantidad de influencia de turbulencia de turbulence_influence_over_life.
Texture2D turbulence_influence_over_life 🔗
La cantidad de turbulencia de cada partícula será influenciada a lo largo de esta CurveTexture durante su vida útil.
float turbulence_initial_displacement_max = 0.0 🔗
Máximo desplazamiento de la posición de aparición de cada partícula por la turbulencia.
La cantidad real de desplazamiento será un factor de la turbulencia subyacente multiplicado por un valor aleatorio entre turbulence_initial_displacement_min y turbulence_initial_displacement_max.
float turbulence_initial_displacement_min = 0.0 🔗
Mínimo desplazamiento de la posición de aparición de cada partícula por la turbulencia.
La cantidad real de desplazamiento será un factor de la turbulencia subyacente multiplicado por un valor aleatorio entre turbulence_initial_displacement_min y turbulence_initial_displacement_max.
float turbulence_noise_scale = 9.0 🔗
Este valor controla la escala/frecuencia general del patrón de ruido de turbulencia.
Una escala pequeña dará como resultado características más pequeñas con más detalle, mientras que una escala alta dará como resultado un ruido más suave con características más grandes.
Vector3 turbulence_noise_speed = Vector3(0, 0, 0) 🔗
Una velocidad de desplazamiento para el campo de turbulencia. Esto establece una tendencia direccional para que el patrón se mueva con el tiempo.
El valor predeterminado de Vector3(0, 0, 0) desactiva el desplazamiento.
float turbulence_noise_speed_random = 0.2 🔗
The in-place rate of change of the turbulence field. This defines how quickly the noise pattern varies over time.
A value of 0.0 will result in a fixed pattern.
float turbulence_noise_strength = 1.0 🔗
La fuerza del ruido de la turbulencia. Aumentar esto resultará en un patrón de flujo más fuerte y contrastado.
bool use_rotation_3d = false 🔗
Enable the usage of rotation_3d_min and rotation_3d_max.
bool use_rotation_velocity_3d = false 🔗
Enable 3D rotation velocity.
Enable the usage of scale_3d_min and scale_3d_max.
Texture2D velocity_limit_curve 🔗
Una CurveTexture que define la velocidad máxima de una partícula durante su vida útil.
Vector3 velocity_pivot = Vector3(0, 0, 0) 🔗
Un punto de pivote utilizado para calcular la velocidad radial y orbital de las partículas.
Descripciones de Métodos
Vector2 get_param(param: Parameter) const 🔗
Devuelve los valores mínimo y máximo del param dado como un vector.
El componente x del vector devuelto corresponde al mínimo y el componente y corresponde al máximo.
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.
Texture2D get_param_texture(param: Parameter) const 🔗
Devuelve la Texture2D utilizada por el parámetro especificado.
bool get_particle_flag(particle_flag: ParticleFlags) const 🔗
Devuelve true si la bandera de partícula especificada está habilitada.
void set_param(param: Parameter, value: Vector2) 🔗
Establece los valores mínimo y máximo del param dado.
El componente x del vector argumento corresponde al mínimo y el componente y corresponde al máximo.
void set_param_max(param: Parameter, value: float) 🔗
Establece el rango de valores máximo para el parámetro dado.
void set_param_min(param: Parameter, value: float) 🔗
Establece el rango de valores mínimo para el parámetro dado.
void set_param_texture(param: Parameter, texture: Texture2D) 🔗
Establece la Texture2D para el Parameter especificado.
void set_particle_flag(particle_flag: ParticleFlags, enable: bool) 🔗
Sets the particle_flag to enable.