ParticleEmitter3D QML Type

Émetteur de particules logiques. Plus d'informations...

• Liste de tous les membres, y compris les membres hérités

Propriétés

• 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éthodes

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

Description détaillée

Cet élément émet des particules logiques dans le site ParticleSystem3D, avec les attributs de départ donnés.

Il faut qu'il y ait au moins un émetteur pour qu'il y ait des particules dans le site ParticleSystem3D. Il existe plusieurs façons de contrôler la quantité de particules émises :

• Régler la propriété emitRate qui contrôle le nombre de particules par seconde émises en continu.
• Ajouter des éléments EmitBurst3D dans la propriété emitBursts pour émettre des rafales de manière déclarative.
• Appeler l'une des méthodes burst() pour émettre des salves immédiatement.

Documentation sur les propriétés

EmitMode : enumeration [since 6.10]

Définit le mode d'émission de l'émetteur avec la forme.

Cette propriété a été introduite dans Qt 6.10.

depthBias : real

Indique le biais de profondeur de l'émetteur. Le biais de profondeur est ajouté à la distance de l'objet par rapport à la caméra lors du tri des objets. Il peut être utilisé pour forcer l'ordre de rendu entre des objets proches les uns des autres, qui pourraient autrement être rendus dans un ordre différent dans des images différentes. Les valeurs négatives rapprochent la valeur de tri de la caméra, tandis que les valeurs positives l'éloignent de la caméra.

emitBursts : List<EmitBurst3D>

Cette propriété prend une liste d'éléments EmitBurst3D, pour définir de manière déclarative les rafales. Si l'heure de début, la quantité et la durée de la salve sont connues à l'avance, il est préférable d'utiliser cette propriété plutôt que d'appeler, par exemple, burst() avec un élément Timer.

Par exemple, pour émettre 100 particules au début et 50 particules après 2 secondes :

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

Voir aussi burst().

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

Cette propriété définit le mode d'émission de l'émetteur avec forme.

Cette propriété a été introduite dans Qt 6.10.

emitRate : real

Cette propriété définit le taux d'émission constant en particules par seconde. Par exemple, si la valeur emitRate est de 120 et que le système s'anime à 60 images par seconde, 2 nouvelles particules sont émises à chaque image.

La valeur par défaut est 0.

enabled : bool

Si enabled vaut false, cet émetteur n'émettra aucune particule. En général, cette option est utilisée pour activer ou désactiver un émetteur de manière conditionnelle. Si vous souhaitez continuer à émettre des éclats, maintenez emitRate à 0 au lieu de passer à false.

La valeur par défaut est true.

lifeSpan : int

Cette propriété définit la durée de vie d'une particule unique en millisecondes.

La valeur par défaut est 1000.

Voir aussi lifeSpanVariation.

lifeSpanVariation : int

Cette propriété définit la variation de la durée de vie d'une particule unique en millisecondes.

Par exemple, pour émettre des particules qui existeront entre 3 et 4 secondes :

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

La valeur par défaut est 0.

Voir aussi lifeSpan.

particle : Particle3D

Cette propriété définit la particule logique émise par cet émetteur. L'émetteur doit avoir une particule définie, sinon il n'émet rien. La particule peut être SpriteParticle3D ou ModelParticle3D.

particleEndScale : real

Cette propriété définit le multiplicateur d'échelle des particules à la fin de la particule lifeSpan. Pour obtenir des variations dans les tailles finales des particules, utilisez particleEndScaleVariation. Lorsque la valeur est négative, l'échelle finale est la même que celle de particleScale, de sorte que l'échelle ne change pas au cours de la particule lifeSpan.

La valeur par défaut est -1.0.

Voir également particleScale et particleScaleVariation.

particleEndScaleVariation : real

Cette propriété définit la variation d'échelle des particules à la fin. Lorsque la valeur est négative, particleScaleVariation est également utilisé pour l'échelle finale. Par exemple, pour émettre des particules qui commencent à l'échelle 0.5 - 1.5 et finissent à l'échelle 1.0 - 5.0 :

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

La valeur par défaut est -1.0.

Voir aussi particleEndScale.

particleRotation : vector3d

Cette propriété définit la rotation des particules au début. La rotation est définie en degrés dans les angles d'Euler.

Voir aussi particleRotationVariation.

particleRotationVariation : vector3d

Cette propriété définit la variation de rotation des particules au début. La variation de rotation est définie en degrés dans les angles d'Euler.

Par exemple, pour émettre des particules avec des rotations totalement aléatoires :

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

Voir aussi particleRotation.

particleRotationVelocity : vector3d

Cette propriété définit la vitesse de rotation des particules au début. La vitesse de rotation est définie en degrés par seconde dans les angles d'Euler.

Voir également particleRotationVelocityVariation.

particleRotationVelocityVariation : vector3d

Cette propriété définit la variation de la vitesse de rotation des particules. La variation de la vitesse de rotation est définie en degrés par seconde dans les angles d'Euler.

Par exemple, pour émettre des particules dans des rotations aléatoires qui ont une vitesse de rotation aléatoire entre -100 et 100 degrés par seconde dans n'importe quelle direction :

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

Voir aussi particleRotationVelocity.

particleScale : real

Cette propriété définit le multiplicateur d'échelle des particules au début. Pour faire varier la taille des particules, utilisez particleScaleVariation.

La valeur par défaut est 1.0.

Voir également particleEndScale et particleScaleVariation.

particleScaleVariation : real

Cette propriété définit la variation d'échelle des particules. Par exemple, pour émettre des particules à l'échelle 0.5 - 1.5 :

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

La valeur par défaut est 0.0.

Voir aussi particleScale et particleEndScaleVariation.

reversed : bool [default: false, since 6.10]

Cette propriété inverse le temps des particules, c'est-à-dire que les particules émises sont exécutées de l'heure de fin à l'heure de début.

Cette propriété a été introduite dans Qt 6.10.

shape : ParticleAbstractShape3D

Cette propriété définit la forme optionnelle de la zone d'émission. Elle peut être ParticleShape3D ou ParticleModelShape3D. La forme est mise à l'échelle, positionnée et tournée en fonction des propriétés du nœud émetteur. Lorsque la propriété Shape fill est définie sur false, l'émission se fait uniquement à partir de la surface de la forme.

Lorsque la forme n'est pas définie, l'émission se fait à partir du point central du nœud émetteur.

system : ParticleSystem3D

Cette propriété définit le site ParticleSystem3D pour l'émetteur. Si le système est le parent direct de l'émetteur, cette propriété n'a pas besoin d'être définie.

velocity : Direction3D

Cette propriété peut être utilisée pour définir la vitesse de départ des particules émises. Si la vitesse n'est pas définie, les particules commencent immobiles et la vitesse provient de affectors si elles sont utilisées.

Documentation de la méthode

vector3d burst(int count)

Cette méthode émet count quantité de particules de cet émetteur immédiatement.

vector3d burst(int count, int duration)

Cette méthode émet count quantité de particules de cet émetteur au cours des prochaines duration millisecondes.

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

Cette méthode émet count quantité de particules de cet émetteur au cours des prochaines duration millisecondes. Les particules sont émises comme si l'émetteur était à position mais toutes les autres propriétés sont les mêmes.