Lo swap chain è il sistema creato da DirectX per gestire il rendering su più oggetti separati (più form o più pictureBox). Non molto utile per la maggior parte dei giochi lo swap chain è fondamentale per numerosissime applicazioni. Un editor grafico 3D ha ad esempio bisogno di gestire su più aree diverse inquadrature di una stessa scena o potrebbe servire realizzare un programma su più finestre separate. Cosa fate in questo caso? Ci sono solo 2 soluzioni:

1) creazione di più device (appesantimento eccessivo del programma);

2) utilizzo dei swapChain.

Ogni oggetto swapChain è una specie di miniDevice in grado di mantenere al suo interno un backBuffer e di direzionale un rendering verso un oggetto stabilito da noi. Inoltre ogni swap sarà indipendente per caratteristiche ma potrà utilizzare tutte le risorse messe a disposizione.

Codice

Innanzitutto creiamo e dichiariamo una superficie

Dim backB As Surface
backB = device.GetBackBuffer(0, 0, BackBufferType.Mono)

Questa superficie sarà il backBuffer principale del device che dovrà essere conservato. Ora creiamo una swapChain

Dim sw1 As Direct3D.SwapChain
Dim s1 As Surface
sw1 = New Direct3D.SwapChain(device, settaggio)
s1 = sw1.GetBackBuffer(0, BackBufferType.Mono)

settaggio è una variabile presentParameters. Se ricordate il device viene creato utilizzando questa variabile per impostare risoluzione, colore e tutte le sue caratteristiche. Similmente impostate le proprietà per un device e utilizzatele per creare una swapChain. Come per il device salvate il backBuffer della swapChain su una superficie. Ora andiamo a renderizzare:

per renderizzare su una swapChain semplicemente

device.SetRenderTarget(0, s1)
device.Clear(ClearFlags.Target Or ClearFlags.ZBuffer, Color.Blue, 1, 0)
device.BeginScene()
'Rendering della scena
device.EndScene()
sw1.Present()

come potete vedere diciamo al device di utilizzare come renderTarget la superficie associata al backBuffer. Dopo di chè utiliziamo il device normalmente pulendo la scena, impostando la visuale e renderizzando tutto quello che volete. Al momento del present utilizzate quello dell swapChain. La scena sarà renderizzata sullo swapChain e la scena apparirà sul controllo scelto.

Ripetete la stessa procedura per eventuali altre swap create. Per tornare a renderizzare sul device è sufficiente ridare ad esso il suo backBuffer

device.SetRenderTarget(0, backB)

da qui in poi renderizzate normalmente.

Potete differenziare come volete gli swapChain eccetto per lo ZBuffer e lo stencil. Se volete utilizzare depth buffer differenti (ad esempio volte uno schermo veloce ed uno preciso magari anche con stencil buffer attivato per renderizzare le ombre) dovrete creare una superficie adatta e passarla al device prima del rendering

device.DepthStencilSurface =superficie

in questo modo potrete cambiare anche lo stencil (ricordate di conservare il buffer originale salvandolo su una superficie).

Conclusioni

1)lo swap chain è il sistema più veloce ed affidabile per il rendering su più oggetti

2)non è saggio utilizzare il metodo in fullscreen ma ad ogni modo puà esistere solo uno tra device e swap in fullscreen

3)tutte le mesh e risorse sono condivise

4)telecamere e settaggi non vengono mantenuti tra le chiamate quindi dovrete cambiarli continuamente se diversi.

Vi lascio agli esempi:

Esempio C#