Création d'effets de particules

Les effets de particules. Quelle superbe chose. Vous pouvez avoir des milliers de petits panneaux calculés interactivement et basés sur les données que vous voulez pour le comportement souhaité des particules. Le système d'effet de particules a complètement été repensé pour Ultimate 3D 2.0 et a été amélioré un petit peu dans Ultimate 3D 2.1. Il est réellement flexible. Tout d'abord, il y a de nombreux paramètres que vous pouvez modifier pour définir les propriétés de vos particules tels que l'origine, la vélocité, l'accélération, la taille et la couleur. Deuxièmement, vous pouvez ajouter de émetteurs de gravité qui fonctionne de manière réaliste. En fait, vous pourriez utiliser le système d'effets de particules avec les émétteurs de gravité pour faire un simulateur de système solaire :D. Pour finir, vous pouvez définir des modificateurs qui changent le comportement de vos particules lorsqu'elles sont dans une zone que vous avez défini. Cela peut être utilisé, par exemple, pour créer une room qui renvoie les particules lorsqu'elles frappent l'un des murs en changeant leur couleur. De plus, chacune des particules dans Ultimate 3D peut avoir une taille illimitée. Et utiliser les effets de particule est très simple, donc ne manquez pas le chapitre qui suit ;).

Création d'un système de particules et configuration de ses propriétés basiques

La création d'un système de particules est certainement la chose la plus simple que vous pouvez imaginer. Vous n'avez pas à définir de variables, tout ce que vous avez à faire est de mettre un appel à CreateParticleSystem() dans l'evènement create d'un objet. Mais il est évident que ce ne peut être tout. Vous devez dire à Ultimate 3D à quoi vous voulez que le système de particules ressemble. Pour cette raison, il vous faut faire appel à un certain nombre d'autres fonctions après l'appel de CreateParticleSystem(). Il y a aussi deux variables que vous pouvez définir à n'importe quel moment. La première est texture, qui définit l'indice de la texture à utiliser. La deuxième est optionelle et est nommée aspect_ratio. Vous pouvez l'utiliser si vous ne voulez pas de particules carrés. La hauteur des particules est toujours égale à leur taille, la largeur est la taille multipliée par aspect_ratio. Les autres options sont définies à l'aide des fonctions. Les deux premières fonctions définissent le nombre de particules qui seront créés à chaque step, et le temps de vie des particules. Les fonctions qui suivront auront toujours quelques paramètres communs, un avec une valeur minimale et un avec une valeur maximale. Ultimate 3D choisira une valeur aléatoire entre la valeur minimale et maximale lorsqu'il aura besoin de cette valeur. De cette façon tout ira de façon un peu aléatoire et chaque particule aura son propre comportement. Voici les deux fonctions:

Cette fonction définit le nombre de particules que le système de particules créera.

`SetParticleCount(` `MinimumParticleCount,` `MaximumParticleCount,` `MaximumTotalParticleCount` `)`

MinimumParticleCount, MaximumParticleCount
Le nombre de particules qui doivent être créées à chaque step.

MaximumTotalParticleCount
Le nombre maximum de particules qui peuvent exister en même temps. Si le nombre total de particules approche cette valeur, Ultimate 3D stoppera la création de particules jusqu'à ce que suffisamment de particules aient dépassées leur durée de vie. Habituellement une bonne valeur pour ce paramètre est:

( MaximumLifetime+MinimumLifetime)/2*(MaximumParticleCount+MinimumParticleCount)/2

Cette fonction définit la durée de vie des particules du système de particules qui appelle la fonction. La durée de vie (en step) est le temps passé depuis leur création jusqu'à ce qu'elles soient détruites.

`SetParticleLifetime(` `MinimumParticleLifetime,` `MaximumParticleLifetime` `)`

MinimumParticleLifetime, MaximumParticleLifetime
La durée de vie des particules qui seront créées.

Maintenant, cela devient un petit peu plus compliqué. Vous allez définir où les particules seront créées. Si vous le souhaitez, vous pouvez simplement passer cette étape. Dans ce cas, toutes les particules seront créées à la même position. Mais cela serait ennuyeux à terme. Pour définir l'origine, vous devez donner une transformation et une valeur réelle. Imaginez que vous avez un modèle de sphère avec un rayon de un. Si vous appliquez la transformation que vous entrez dans la fonction suivante de ce modèle de sphère, le modèle vous montrera les zones où les particules peuvent être créees. La deuxième valeur réelle sera utilisée comme une mise à l'échelle pour une deuxième sphère qui utilise la même transformation. C'est l'autre bordure qui limite la zone où les particules seront créées. Le schéma suivant illustre ce principe.

La première sphère sera transformée en utilisant la transformation que vous entrerez dans la fonction suivante. Ensuite la seconde sphère sera transformée de la même façon et scalée par le rayon donné de deuxième sphère. Ensuite la zone entre ces deux sphères est l'origine des particules. Voici la fonction pour définir ces propriétés:

Cette fonction définit l'origine des particules. La position de l'origine n'est pas définie par cette fonction étant donné que cela doit être modifié très souvent. Pour cette raison vous devez définir les variables x, y et z pour chaque système de particules.

`SetParticleOrigin(` `SecondSphereRadius,` `RotationX, RotationY, RotationZ,` `ScalingX, ScalingY, ScalingZ` `)`

SecondSphereRadius
Le rayon de la deuxième sphère qui sert de deuxième bordure pour délimiter l'origine des particules. Si vous mettez 0 pour ce paramètre, l'origine des particules sera une sphère exacte.

RotationX, RotationY, RotationZ
La rotation à utiliser pour la transformation des deux sphères. Habituellement vous n'avez pas besoin de ces paramètres, étant donné que faire pivoter l'origine n'a de sens que si vous n'entrez pas la même valeurs pour les trois paramètres de scaling (mise à l'échelle).

ScalingX, ScalingY, ScalingZ
Le scaling qui doit être appliqué à ces deux sphères.

Les deux prochaines fonctions définissent la vélocité des particules et leur accelération (l'accelération est la modification de la vélocité à chaque step). C'est très simple. La seule chose que vous devez garder à l'esprit à propos de ces fonctions est que la longitude doit être située entre -90 et 90 parce qu'autrement la méthode qu'Ultimate 3D utilise pour réaliser une diffusion régulière des particules ne fonctionnera pas correctement.

Cette fonction définit la vélocité initiale des particules qui sont créées par le système de particules.

`SetParticleVelocity(` `MinLongitude, MinLatitude,` `MinVelocity,` `MaxLongitude, MaxLatitude,` `MaxVelocity` `)`

MinLongitude, MinLatitude, MaxLongitude, MaxLatitude
La direction des mouvements donnée en degrés. Les valeurs de longitude doivent être entre -90 et 90.

MinVelocity, MaxVelocity
La vitesse du mouvement par step.

Cette fonction définit l'accélération initiale des particules qui sont créées par le système de particules.

`SetParticleAcceleration(` `MinLongitude, MinLatitude,` `MinAcceleration,` `MaxLongitude, MaxLatitude,` `MaxAcceleration` `)`

MinLongitude, MinLatitude, MaxLongitude, MaxLatitude
La direction de changement du mouvement en degrés. Les valeurs de longitude doivent être entre -90 et 90.

MinAcceleration, MaxAcceleration
La force de changement du mouvement à chaque step.

Ensuite vous pouvez définir quelque chose qui se nomme centre de répulsion initial. Il arrive très souvent que toutes les particules sont sensées s'éloigner de l'origine du système de particule. Un exemple pour cela serait un système de particule pour les explosions. C'est pour cela que vous avez besoin d'un centre de répulsion initial. Lorsqu'une nouvelle particule est créée le facteur du centre de répulsion initial est multiplié par la différence de position de la particule et du système de particule. Puis le résultat est ajouté à la vélocité initiale de la particule ( VelociteInitiale += (PositionParticule - PositionSystemeParticule)*FacteurRepulsion). Le facteur de répulsion est défini individuellement pour chaque axe. Voici la fonction:

Elle définit le facteur du centre de répulsion initial:

`SetInitialCenterRepulsion(` `RepulsionFactorX, RepulsionFactorY, RepulsionFactorZ` `)`

RepulsionFactorX, RepulsionFactorY, RepulsionFactorZ
Le facteur de répulsion le long de chaque axe. Pour obtenir une description de ce qu'est le facteur de répulsion, jetez un oeil au texte ci-dessus.

Ensuite vous pouvez définir la couleur et la taille des particules. Pour chacune d'elle vous pouvez définir une fourchette de valeurs initiales possibles et une fourchette de valeurs finales possibles. Les valeurs finales seront utilisées par les particules à la fin de leur durée de vie. Voici les fonctions disponibles pour définir ces valeurs:

Cette fonction définit un éventail de valeurs de couleurs initiales possibles pour les particules.

`SetInitialParticleColor(` `MinimumR, MinimumG, MinimumB, MinimumA,` `MaximumR, MaximumG, MaximumB, MaximumA` `)`

MinimumR, MinimumG, MinimumB, MinimumA
Les valeurs de couleurs minimales pour les couleurs initiales des particules. Ces valeurs doivent être dans la fourchette allant de 0 à 255. MinimumA définit le minimum de l'opacité (0 pas d'opacité (totalement transparent), 255 pour une couleur complètement opaque).

MaximumR, MaximumG, MaximumB, MaximumA
La valeur de couleur maximale pour la couleur initiale de la particule. Ces valeurs doivent également rester dans la fourchette allant de 0 à 255.

Cette fonction définit un éventail de valeurs de couleurs finales possibles pour les particules.

`SetFinalParticleColor(` `MinimumR, MinimumG, MinimumB, MinimumA,` `MaximumR, MaximumG, MaximumB, MaximumA` `)`

MinimumR, MinimumG, MinimumB, MinimumA, MaximumR, MaximumG, MaximumB, MaximumA
Ces paramètres ont la même signification que pour SetInitialParticleColor(...) mais cette fois-ci, ils se réfèrent à la couleur finale des particules.

Cette fonction définit un éventail de tailles de particules initiales et finales possibles. Les valeurs de tailles sont données dans l'espace du monde, elles sont donc interprétées de la même façon que les paramètres que vous pouvez définir pour les billboards.

`SetParticleSize(` `MinInitialSize, MaxInitialSize,` `MinFinalSize, MaxFinalSize` `)`

MinInitialSize, MaxInitialSize
L'éventail de tailles initiales possibles pour les particules.

MinFinalSize, MaxFinalSize
L'éventail de tailles possibles que les particules peuvent avoir à la fin de leur durée de vie.

Enfin vous pouvez déterminer une rotation pour les particules. Faire pivoter les particules rend le système de particule un peu plus chaotique et cela s'ajoute surperbement à leur apparence naturelle.

Cette fonction détermine la rotation initiale des particules et leur vitesse de rotation.

`SetParticleRotation(` `MinInitialRotation, MaxInitialRotation,` `MinRotationSpeed, MaxRotationSpeed` `)`

MinInitialRotation, MaxInitialRotation
L'éventail possible des rotations initiales pour les particules en degrés. Une rotation de zero, signifie que le haut de la texture est en haut de la particule. Des rotations plus grandes font pivoter les particules sur l'écran dans le sens des aiguilles d'une montre.

MinRotationSpeed, MaxRotationSpeed
L'éventail possible des vitesses de rotation pour les particules en degrés. La vitesse de rotation sera ajoutée à l'angle de rotation de la particule une fois par step.

Maintenant que vous savez comment définir les propriétés d'un système de particules, il est temps de le faire vivre. Pour ce faire vous devez mettre un appel de fonction dans l'évènement step de l'objet que vous avez créé pour le système de particule, mais cette fois ci ce n'est pas Step(). Ce choix est dû au fait que la fonction step des systèmes de particules prend un paramètre et ne requiert pas d'être appelé à chaque step, parce qu'elle prend un bon petit temps de calcul selon le nombre de particules, d'émetteurs de gravité et de modificateurs. Cela n'a pas de sens de réaliser un step pour un système de particules complexe s'il n'est pas actuellement visible. Voici la fonction:

Cette fonction effectue un step de la longueur donné pour le système de particules qui appelle la fonction.

`ParticleSystemStep(` `StepLength` `)`

StepLength
La longueur du step que vous voulez effectuer. On pourrait également nommer cela un facteur de temps. Si vous mettez un ici, un step sera effectué à chaque appel de cette fonction. Si vous mettez 0.5, tout fonctionnera à la moitié de la vitesse, et si vous mettez 2 tout ira deux fois plus vite. Notez qu'un facteur de temps élevé peut donner des calculs imprécis, spécialement lors de l'usage de modificateurs et d'émetteurs de gravité.

Enfin, il vous faudra faire appel à Destroy() dans l'évènement destroy de l'objet de système de particule, sinon le système de particule sera toujours visible après la destruction de l'objet avec lequel il était associé.

Si vous voulez obtenir des effets de particules très brillants avec un effet volumétrique vous voulez peut être utiliser l'additive blending pour les systèmes d'effets de particules. L'additive blending signife que chaque particule s'ajoute à la couleur de l'écran, à la place de la couvrir. Sans additive blending cinq particules les unes sur les autres, apparaissent exactement de la même façon qu'une particule seule, étant donné que la particule devant couvre les quatres autres. Avec l'additive blending les couleurs des particules sont ajoutées ensembles, menant à un spot très brillant (plus brillant qu'une seule particule). Activer l'additive blending est facile.

Cette fonction active ou désactive l'additive blending pour les objets qui l'appelle.

`SwitchAdditiveBlending(` `UseAdditiveBlending` `)`

UseAdditiveBlending
Si ce paramètre est true, l'additive blending sera utilisé pour cet objet, s'il est false, l'additive blending de sera pas utilisé.

Cette fonction ne fonctionne pas seulement pour les systèmes de particule, mais aussi pour les objets de modèles, les objets de terrains et les objets primitifs. Vous ne devriez l'utiliser seulement pour ces types d'objets lorsqu'ils sont partiellement transparents. Sinon le résultat pourrait ne pas être celui escompté du fait du z-buffering.

Emetteurs de gravité

Les émetteurs de gravité sont vraiment cools. Ils peuvent faire en sorte que les particules se déplacent sur des chemins qui sont assez fréquents mais jamais les mêmes. Les émetteurs de gravité peuvent aussi émettre de la gravité "négative", ainsi, elles font s'éloigner les particules, ce qui est utile pour de nombreux effets différents. Les émetteurs de gravité utilisent la physique, ainsi même si vous ne connaissez rien de la théorie de Newton sur la gravité, cela donnera une sensation de comportement naturel. Remarquez que les émetteurs de gravité ne sont pas conçus pour être utilisés pour faire de la gravité qui vient toujours de la même direction. Cela peut être réalisé plus facilement en définissant une accelération constante.

Utiliser les émetteurs de gravité est très facile. Il vous suffit de définir leur position dans l'espace du monde et l'intensité de la gravité qu'ils doivent émettre. Le reste se fait automatiquement. Les émetteurs de gravité doivent être utilisés prudemment étant donné qu'ils seront appliqués à chaque particule, ce qui prend un peu de temps de calcul. Ultimate 3D définit une limite de 32 émetteurs de gravité par système de particules. Voici la fonction que vous devez utiliser pour créer les émetteurs de gravité:

Cette fonction ajoute un nouvel émetteur de gravité au système de particules qui appelle la fonction et retourne son ID, qui peut être utilisé pour le modifier après coup.

`AddGravityEmitter(` `PositionX, PositionY, PositionZ,` `GravityEmitterMass` `)`

PositionX, PositionY, PositionZ
La position de l'émetteur de gravité dans l'espace.

GravityEmitterMass
La masse de l'émetteur de gravité. Une bonne valeur pour ce paramètre dépend de la distance de votre système de particules, vous devriez en trouver une en faisant divers essais.

Cette fonction peut être utilisée pour modifier ou supprimer un émetteur de gravité que vous avez créé auparavant.

`SetGravityEmitter(` `GravityEmitterID,` `PositionX, PositionY, PositionZ,` `GravityEmitterMass` `)`

GravityEmitterID
L'ID de l'émetteur de gravité que vous souhaitez modifier. C'est la valeur retournée par AddGravityEmitter(...) lors de la création de l'émetteur de gravité.

PositionX, PositionY, PositionZ
La nouvelle position de l'émetteur de gravité dans l'espace.

GravityEmitterMass
La nouvelle masse de l'émetteur de gravité. Si vous entrez 0 pour ce paramètre l'émetteur de gravité sera supprimé.

Modificateur de particules

Souvent les particules doivent changer lorsqu'elles arrivent dans une région particulière. Par exemple, si vous faites un système de particules pour ajouter de l'eau pulvérisée à une chute d'eau, les particules doivent remonter vers le haut après avoir touché la surface de l'eau. Des choses comme celle là peuvent être faites facilements à l'aide des modificateurs de particules. Les modificateurs de particules changent les particules lorsqu'elles sont dans la région que vous avez définie. Ils peuvent changer n'importe quelle propriété des particules (durée de vie, vélocité, accelération, couleur et taille). Cela rend le système de particules vraiment flexible et vivant.

Définir les propriétés des modificateurs de particules équivaut à peu près, à définir les propriétés sur système de particules. Tout est fait au travers d'appels de fonctions et beaucoup de propriétés sont similaires à celles que vous pouvez définir pour le système de particules. Mais avant de définir ces propriétés pour les modificateurs de particules, vous devez les créer. Pour ce faire, il vous faut appeller AddModifier(). Cette fonction retournera l'ID du modificateur qui devra être sauvegardé dans une variable, pour être à même de définir n'importe quelle propriété du modificateur. Voici toutes les fonctions dont vous avez besoin pour définir les propriétés du modificateur:

Cette fonction définit la zone qui est affectée par le modificateur de particules. Cela fonctionne de la même façon que la définition de l'origine des particules (voir SetParticleOrigin(...) ). Lorsqu'une particule est dans la zone, elle est modifiée:

`SetModifierEffectedArea(` `ModifierID,` `SecondSphereRadius,` `PositionX, PositionY, PositionZ,` `RotationX, RotationY, RotationZ,` `ScalingX, ScalingY, ScalingZ` `)`

ModifierID
L'ID du modificateur que vous voulez modifier.

SecondSphereRadius
Le rayon de la seconde sphère qui est la deuxième frontière de la zone affectée.

PositionX/Y/Z, RotationX/Y/Z, ScalingX/Y/Z
La transformation des deux sphères qui sont et qui servent de frontières à la zone affectée.

Cette fonction définit un modificateur qui changera la durée de vie d'une particule lorsqu'elle entre dans la zone de ce modificateur. Donc si vous le définissiez à un, une particule ne moura jamais dans la zone affectée, parce que sa durée de vie sera incrémentée (et décrémentée) par un à chaque step.

`SetModifierLifetimeChange(` `ModifierID,` `LifetimeChange` `)`