ParticleEmitter3D QML Type

Emisor de partículas lógicas. Más...

• Lista de todos los miembros, incluidos los heredados

Propiedades

• EmitMode : enumeration (since 6.10)
• depthBias : real
• emitBursts : List<EmitBurst3D>
• emitMode : EmitMode (since 6.10)
• emitRate : real
• enabled : bool
• lifeSpan : int
• lifeSpanVariation : int
• particle : Particle3D
• particleEndScale : real
• particleEndScaleVariation : real
• particleRotation : vector3d
• particleRotationVariation : vector3d
• particleRotationVelocity : vector3d
• particleRotationVelocityVariation : vector3d
• particleScale : real
• particleScaleVariation : real
• reversed : bool (since 6.10)
• shape : ParticleAbstractShape3D
• system : ParticleSystem3D
• velocity : Direction3D

Métodos

• vector3d burst(int count)
• vector3d burst(int count, int duration)
• vector3d burst(int count, int duration, vector3d position)

Descripción detallada

Este elemento emite partículas lógicas en ParticleSystem3D, con los atributos iniciales dados.

Se requiere al menos un emisor para tener partículas en ParticleSystem3D. Hay varias formas de controlar la cantidad de partículas emitidas:

• Establecer el emitRate que controla cuántas partículas por segundo se emiten continuamente.
• Añadir elementos EmitBurst3D en la propiedad emitBursts para emitir ráfagas de forma declarativa.
• Llamar a cualquiera de los métodos burst() para emitir ráfagas inmediatamente.

Documentación de la propiedad

EmitMode : enumeration [since 6.10]

Define el modo de emisión del emisor con forma.

Esta propiedad se introdujo en Qt 6.10.

depthBias : real

Mantiene el sesgo de profundidad del emisor. El sesgo de profundidad se añade a la distancia del objeto desde la cámara cuando se ordenan los objetos. Esto puede usarse para forzar el orden de renderizado entre objetos cercanos, que de otro modo podrían renderizarse en diferente orden en diferentes fotogramas. Los valores negativos hacen que el valor de ordenación se acerque a la cámara, mientras que los valores positivos lo alejan de la cámara.

emitBursts : List<EmitBurst3D>

Esta propiedad toma una lista de elementos EmitBurst3D, para definir de forma declarativa las ráfagas. Si se conocen de antemano la hora de inicio, la cantidad y la duración de la ráfaga, es mejor utilizar esta propiedad que, por ejemplo, llamar a burst() con un Timer.

Por ejemplo, para emitir 100 partículas al principio, y 50 partículas a los 2 segundos:

ParticleEmitter3D {
    emitBursts: [
        EmitBurst3D {
            time: 0
            amount: 100
        },
        EmitBurst3D {
            time: 2000
            amount: 50
        }
    ]
}

Véase también burst().

emitMode : EmitMode [default: ParticleEmitter3D.Default, since 6.10]

Esta propiedad define el modo de emisión del emisor con forma.

Esta propiedad se introdujo en Qt 6.10.

emitRate : real

Esta propiedad define la tasa de emisión constante en partículas por segundo. Por ejemplo, si el emitRate es 120 y el sistema anima a 60 fotogramas por segundo, se emiten 2 nuevas partículas en cada fotograma.

El valor por defecto es 0.

enabled : bool

Si habilitado se establece en false, este emisor no emitirá ninguna partícula. Normalmente esto se utiliza para activar o desactivar condicionalmente un emisor. Si quieres continuar emitiendo ráfagas, mantén emitRate en 0 en lugar de cambiar esto a false.

El valor por defecto es true.

lifeSpan : int

Esta propiedad define el tiempo de vida de una partícula individual en milisegundos.

El valor por defecto es 1000.

Véase también lifeSpanVariation.

lifeSpanVariation : int

Esta propiedad define la variación del tiempo de vida de una sola partícula en milisegundos.

Por ejemplo, para emitir partículas que existirán entre 3 y 4 segundos:

ParticleEmitter3D {
    ...
    lifeSpan: 3500
    lifeSpanVariation: 500
}

El valor por defecto es 0.

Véase también lifeSpan.

particle : Particle3D

Esta propiedad define la partícula lógica que emite este emisor. El emisor debe tener una partícula definida, o no emite nada. La partícula puede ser SpriteParticle3D o ModelParticle3D.

particleEndScale : real

Esta propiedad define el multiplicador de escala de las partículas al final de partícula lifeSpan. Para tener variación en los tamaños finales de las partículas, utilice particleEndScaleVariation. Cuando el valor es negativo, la escala final es la misma que la de particleScale, por lo que la escala no cambia durante la partícula lifeSpan.

El valor por defecto es -1.0.

Véase también particleScale y particleScaleVariation.

particleEndScaleVariation : real

Esta propiedad define la variación de escala de las partículas en el extremo. Cuando el valor es negativo, particleScaleVariation se utiliza también para la escala final. Por ejemplo, para emitir partículas que comienzan en la escala 0.5 - 1.5 y terminan en la escala 1.0 - 5.0:

ParticleEmitter3D {
    ...
    particleScale: 1.0
    particleScaleVariation: 0.5
    particleEndScale: 3.0
    particleEndScaleVariation: 2.0
}

El valor por defecto es -1.0.

Véase también particleEndScale.

particleRotation : vector3d

Esta propiedad define la rotación de las partículas en el inicio. La rotación se define como grados en ángulos euler.

Véase también particleRotationVariation.

particleRotationVariation : vector3d

Esta propiedad define la variación de rotación de las partículas en el inicio. La variación de rotación se define como grados en ángulos de euler.

Por ejemplo, para emitir partículas en rotaciones completamente aleatorias:

ParticleEmitter3D {
    ...
    particleRotationVariation: Qt.vector3d(180, 180, 180)
}

Ver también particleRotation.

particleRotationVelocity : vector3d

Esta propiedad define la velocidad de rotación de las partículas al principio. La velocidad de rotación se define como grados por segundo en ángulos euler.

Véase también particleRotationVelocityVariation.

particleRotationVelocityVariation : vector3d

Esta propiedad define la variación de la velocidad de rotación de las partículas. La variación de la velocidad de rotación se define como grados por segundo en ángulos de Euler.

Por ejemplo, para emitir partículas en rotaciones aleatorias que tengan una velocidad de rotación aleatoria entre -100 y 100 grados por segundo en cualquier dirección:

ParticleEmitter3D {
    ...
    particleRotationVariation: Qt.vector3d(180, 180, 180)
    particleRotationVelocityVariation: Qt.vector3d(100, 100, 100)
}

Véase también particleRotationVelocity.

particleScale : real

Esta propiedad define el multiplicador de escala de las partículas al principio. Para tener variación en el tamaño de las partículas, utilice particleScaleVariation.

El valor por defecto es 1.0.

Véase también particleEndScale y particleScaleVariation.

particleScaleVariation : real

Esta propiedad define la variación de escala de las partículas. Por ejemplo, para emitir partículas a escala 0.5 - 1.5:

ParticleEmitter3D {
    ...
    particleScale: 1.0
    particleScaleVariation: 0.5
}

El valor por defecto es 0.0.

Véase también particleScale y particleEndScaleVariation.

reversed : bool [default: false, since 6.10]

Esta propiedad invierte el tiempo de las partículas, es decir, las partículas emitidas se ejecutan desde el tiempo final hasta el tiempo inicial.

Esta propiedad se introdujo en Qt 6.10.

shape : ParticleAbstractShape3D

Esta propiedad define una forma opcional para el área emisora. Puede ser ParticleShape3D o ParticleModelShape3D. La forma se escala, posiciona y rota basándose en las propiedades del nodo emisor. Cuando la propiedad Shape fill es falsa, la emisión se realiza sólo desde la superficie de la forma.

Cuando la forma no está definida, la emisión se realiza desde el punto central del nodo emisor.

system : ParticleSystem3D

Esta propiedad define la dirección ParticleSystem3D para el emisor. Si el sistema es el padre directo del emisor, no es necesario definir esta propiedad.

velocity : Direction3D

Esta propiedad se puede utilizar para establecer una velocidad inicial para las partículas emitidas. Si no se establece la velocidad, las partículas comienzan inmóviles y la velocidad proviene de affectors si se utilizan.

Documentación del método

vector3d burst(int count)

Este método emite count cantidad de partículas de este emisor inmediatamente.

vector3d burst(int count, int duration)

Este método emite count cantidad de partículas de este emisor durante los próximos duration milisegundos.

vector3d burst(int count, int duration, vector3d position)

Este método emite count cantidad de partículas desde este emisor durante los próximos duration milisegundos. Las partículas se emiten como si el emisor estuviera en position pero el resto de propiedades son las mismas.