\\ Home : Articoli : Stampa
Sistemi di Particelle
Di RobyDx (del 28/01/2007 @ 15:55:41, in DirectX9, linkato 2483 volte)

Un sistema a particelle è la realizzazione di un effetto visivo che si basa sul movimento di numerosi oggetti simili tra loro. Un esempio di sistemi a particelle è ad esempio la pioggia o la neve, scintille o tempeste di sabbia. Tutte queste situazioni sono composte da un numero più o meno elevato di oggetti simili tra loro che seguono una regola comune nel loro movimento (la pioggia ad esempio è composta da tante gocce che cadono più o meno verticalmente). Nella computer grafica le particelle sono utilizzate per rappresentare in 3D diverse situazioni non facilmente realizzabili con un modello solido come ad esempio fiamme o getti d’acqua. Quello che a prima vista si potrebbe risolvere muovendo tanti oggetti sullo schermo si scontra con la potenza effettiva dei computer attuali. Una pioggia con appena 100 gocce si tramuterebbe in un appesantimento eccessivo per ogni sistema e di conseguenza agire in questo senso non và bene. Per questo le librerie grafiche hanno adottato sistemi particolarmente efficienti per rappresentare un gran numero di particelle sullo schermo. In DirectX si chiamano Point Sprite.

Esempio particelle

In DirectX le particelle vengono gestite attraverso array di vertici che vengono renderizzati però non come trianglelist ma come pointlist. Attivando la relativa opzione al posto di ogni vertice verrà tracciata una immagine che dovrà essere inserita come texture prima di renderizzare l’array di vertici. Sono supportati tutti i tipi di vertici anche quelli con caratteristiche come colore.
Per attivare un pointsprite è sufficiente impostare l’opzione

device.RenderState.PointSpriteEnable = True

Creare un array di vertici ed una texture e renderizzare con un drawUserPrimitive

device.SetTexture(0, texture)
device.DrawUserPrimitives(PrimitiveType.PointList, numero_vertici, arrayVertici)

Ovviamente c’è molto da considerare.
Innanzitutto occorre settare un colore di trasparenza per la texture ed attivare l’alphablending per fare in modo che non si veda.

Per questa texture ad esempio sarà necessario impostare come bianco il colore trasparente ed attivare l’alphablending con delle opzioni simili a queste

device.RenderState.AlphaBlendEnable = True
device.RenderState.SourceBlend = Blend.SourceAlpha
device.RenderState.DestinationBlend = Blend.DestinationAlpha

In questo modo si vedrà solo la particella e non il quadrato bianco intorno.
Potete anche settare la dimensione ed il comportamento di questa nel movimento delle particelle.

device.RenderState.PointScaleEnable = True
device.RenderState.PointScaleA = 0.0F
device.RenderState.PointScaleB = 0.0F
device.RenderState.PointScaleC = 1.0F

Attivando il pointscale e impostando I valori A,B e C significa rispettare questa regola matematica

Ss = Vh * Si * sqrt( 1 / ( A + B * De + C * ( De2 ) ) )

Dove Ss è la dimensione finale della particella, Vh è l’altezza del viewport (il viewport è un settaggio che imposta la posizione e dimensione dello schermo 3D sullo schermo) e De è la distanza del punto dal punto di vista (posizione della telecamera).
A,B e C sono i valori impostati nel device mentre Si è la dimensione iniziale che è specificata dalla proprietà

device.RenderState.PointSize = 2.0F

Infine è possibile controllare la dimensione minima e massima impostando

device.RenderState.PointSizeMin = 0.0F
device.RenderState.PointSizeMax = 5.0F

Tutti questi valori sono semplicemente single (chi conosce DirectX8 sapeva che occorreva usare i DWORD qui fortunatamente aboliti).
Per chi non vuole scervellarsi con la formula deve semplicemente provare valori finche non trova l’effetto voluto (molto casareccia ma efficace).
Le dimensioni sono espresse in unità schermo (come la maggior parte delle cose in DirectX).
Ora non vi resta che creare un programma che gestisca le particelle (cosa a cui dovrete sempre provvedere da soli). Con una scheda sufficientemente buona non avrete problemi a renderizzare migliaia di particelle di qualunque tipo e dimensione. Se usate vertici con colori ogni particella virerà verso il colore del proprio vertice mentre con altri tipi di vertici dovrete settare il materiale con un colore (il migliore da usare è l’emissive) ma in questo caso tutte le particelle avranno lo stesso colore.
Ultime note.

  • Non tutte le schede (fortunatamente solo le più vecchie) supportano i point sprite (controllate con le enumerazioni).

  • Le particelle sono un array di vertici e di conseguenza seguono la matrice di movimento. Occhio che in molti casi è preferibile traslare soltanto perché le rotazioni creano effetti poco gradevoli.

  • Ripassate un pò di fisica dato che per molti effetti le particelle vengono influenzate da gravità e vento o per lo meno seguono regole precise.

  • Usate texture piccole per le particelle in modo da non appesantire più del dovuto il sistema (vi potrete permettere più particelle).

    Si conclude questo tutorial che, spero, vi avrà insegnato ad usare questo effetto ormai pressochè comune ma estremamente spettacolare se ben usato (il difficile è infatti gestire le particelle). Vi lascio al mio esempio, non molto elaborato ma spero chiaro. Ultimo consiglio: usate oggetti per le particelle!

    Esempio VB.Net

    Esempio C#