ParticleEmitter3D QML Type

Émetteur de particules logiques. En savoir plus...

• 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 l'ParticleSystem3D, avec les attributs initiaux indiqués.

Au moins un émetteur est nécessaire pour qu’il y ait des particules dans l’ ParticleSystem3D. Il existe plusieurs façons de contrôler le nombre de particules émises :

• Définissez la propriété ` emitRate `, qui contrôle le nombre de particules émises en continu par seconde.
• Ajoutez des éléments d’ EmitBurst3D à la propriété « emitBursts » pour émettre des rafales de manière déclarative.
• Appelez l’une des méthodes burst() pour émettre des rafales immédiatement.

Documentation sur les propriétés

EmitMode : enumeration [since 6.10]

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

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

depthBias : real

Stocke le décalage de profondeur de l'émetteur. Le décalage de profondeur est ajouté à la distance de l'objet par rapport à la caméra lors du tri des objets. Cela permet de forcer l'ordre de rendu entre des objets proches les uns des autres, qui pourraient sinon être rendus dans un ordre différent d'une image à l'autre. Les valeurs négatives rapprochent l'objet de la caméra, tandis que les valeurs positives l'éloignent de celle-ci.

emitBursts : List<EmitBurst3D>

Cette propriété prend une liste d'éléments de type « EmitBurst3D » afin de définir de manière déclarative des rafales. Si l'heure de début, le nombre et la durée de la rafale sont connus à l'avance, il est préférable d'utiliser cette propriété plutôt que, par exemple, d'appeler la méthode ` burst()` avec un ` Timer`.

Par exemple, pour émettre 100 particules au début, puis 50 particules au bout de 2 secondes :

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

Voir également burst().

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

Cette propriété définit le mode d'émission de l'émetteur doté d'une 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 de `emitRate` est égale à 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 le paramètre « enabled » est défini sur « false », cet émetteur n'émettra aucune particule. En général, cela sert à activer ou désactiver un émetteur de manière conditionnelle. Si vous souhaitez continuer à émettre des rafales, maintenez la valeur de « emitRate » à 0 au lieu de la basculer sur « false ».

La valeur par défaut est « true ».

lifeSpan : int

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

La valeur par défaut est « 1000 ».

Voir également lifeSpanVariation.

lifeSpanVariation : int

Cette propriété définit la variation de la durée de vie d'une particule unique, exprimée 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 également lifeSpan.

particle : Particle3D

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

particleEndScale : real

Cette propriété définit le facteur d'échelle des particules à la fin de l'lifeSpan. Pour obtenir une variation de la taille finale des particules, utilisez particleEndScaleVariation. Lorsque la valeur est négative, l'échelle finale est identique à celle de l'particleScale, de sorte que l'échelle ne change pas pendant l'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, la valeur « particleScaleVariation » est également utilisée pour l'échelle finale. Par exemple, pour émettre des particules dont l'échelle initiale est comprise entre 0,5 et 1,5 et dont l'échelle finale est comprise entre 1,0 et 5,0 :

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

La valeur par défaut est « -1.0 ».

Voir également « particleEndScale ».

particleRotation : vector3d

Cette propriété définit la rotation initiale des particules. La rotation est exprimée en degrés sous forme d'angles d'Euler.

Voir également particleRotationVariation.

particleRotationVariation : vector3d

Cette propriété définit la variation de rotation des particules au début. La variation de rotation est exprimée en degrés sous forme d'angles d'Euler.

Par exemple, pour émettre des particules avec des rotations entièrement aléatoires :

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

Voir également particleRotation.

particleRotationVelocity : vector3d

Cette propriété définit la vitesse de rotation initiale des particules. La vitesse de rotation est exprimée 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 exprimée en degrés par seconde dans les angles d'Euler.

Par exemple, pour émettre des particules avec des rotations aléatoires et une vitesse de rotation aléatoire comprise entre -100 et 100 degrés par seconde dans toutes les directions :

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

Voir également particleRotationVelocity.

particleScale : real

Cette propriété définit le facteur d'échelle des particules au départ. Pour obtenir une variation de 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 dont l'échelle est comprise entre 0,5 et 1,5 :

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

La valeur par défaut est 0.0.

Voir également « particleScale » et « particleEndScaleVariation ».

reversed : bool [default: false, since 6.10]

Cette propriété inverse la durée des particules, c'est-à-dire que les particules émises sont calculées de la fin vers le début.

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

shape : ParticleAbstractShape3D

Cette propriété définit la forme facultative de la zone d'émission. Elle peut prendre l'une des valeurs suivantes : « ParticleShape3D » ou « ParticleModelShape3D ». La forme est mise à l'échelle, positionnée et pivoté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 s'effectue à partir du point central du nœud émetteur.

system : ParticleSystem3D

Cette propriété définit l'ParticleSystem3D e de l'émetteur. Si « system » est le parent direct de l'émetteur, il n'est pas nécessaire de définir cette propriété.

velocity : Direction3D

Cette propriété permet de définir une vitesse initiale pour les particules émises. Si aucune vitesse n’est définie, les particules démarrent à l’arrêt et leur vitesse est déterminée par affectors si cette méthode est utilisée.

Documentation de la méthode

vector3d burst(int count)

Cette méthode émet immédiatement une quantité d count e de particules à partir de cet émetteur.

vector3d burst(int count, int duration)

Cette méthode émet une quantité de particules égale à count à partir de cet émetteur pendant les duration millisecondes suivantes.

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

Cette méthode émet un count e quantité de particules à partir de cet émetteur pendant les duration millisecondes suivantes. Les particules sont émises comme si l'émetteur se trouvait à l'adresse position, mais toutes les autres propriétés restent inchangées.