Il modo più veloce per eseguire il rendering di linee con AA, variando lo spessore in DirectX

Quindi sto sviluppando alcuni DirectX, usando SharpDX sotto .NET per l'esattezza (ma le soluzioni API DirectX / C ++ sono applicabili). Sto cercando il modo più veloce per eseguire il rendering di linee in una proiezione ortogonale (ad esempio, simulando il disegno 2D per app scientifiche) utilizzando DirectX.

Ecco uno screenshot del tipo di grafici che sto cercando di rendere:

Non è raro che questo tipo di grafici abbia linee con milioni di segmenti, di spessore variabile, con o senza antialiasing per linea (o AA a schermo intero on / off). Devo aggiornare i vertici delle linee molto frequentemente (ad es. 20 volte al secondo) e scaricare il più possibile sulla GPU.

Finora ho provato:

1. Il rendering del software, ad esempio GDI +, in realtà non è male, ma ovviamente è pesante per la CPU
2. API Direct2D: più lenta di GDI, in particolare con Antialiasing attivo
3. Direct3D10 utilizza questo metodo per emulare AA usando i colori dei vertici e la tassellatura sul lato CPU. Anche lento (l'ho profilato e l'80% del tempo è impiegato nel calcolo delle posizioni dei vertici)

Per il 3o metodo sto usando Vertex Buffers per inviare una striscia triangolare alla GPU e aggiornando ogni 200 ms con nuovi vertici. Ricevo una frequenza di aggiornamento di circa 5 FPS per 100.000 segmenti di linea. Ne ho bisogno idealmente milioni!

Ora sto pensando che il modo più veloce sarebbe fare la tassellatura sulla GPU, ad esempio in Geometry Shader. Potrei inviare i vertici come un elenco di linee o impacchettare in una trama e decomprimere in un Geometry Shader per creare i quad. Oppure, basta inviare punti grezzi a un pixel shader e implementare il disegno di Bresenham Line interamente in un pixel shader. Il mio HLSL è arrugginito, shader modello 2 del 2006, quindi non conosco le cose folli che le GPU moderne possono fare.

Quindi la domanda è: - qualcuno l'ha mai fatto prima e hai qualche suggerimento da provare? - Hai qualche suggerimento per migliorare le prestazioni con l'aggiornamento rapido della geometria (ad es. Un nuovo elenco di vertici ogni 20 ms)?

AGGIORNAMENTO 21 gennaio

Da allora ho implementato il metodo (3) sopra usando gli shader Geometry usando LineStrip e Dynamic Vertex Buffer. Ora sto ricevendo 100FPS a 100k punti e 10FPS a 1.000.000 di punti. Questo è un enorme miglioramento, ma ora sono pieno e il calcolo è limitato, quindi ho pensato ad altre tecniche / idee.

• Che dire dell'istanza hardware di una geometria del segmento di linea?
• Che dire di Sprite Batch?
• Che dire di altri metodi orientati (Pixel shader)?
• Posso abbattere efficacemente la GPU o la CPU?

I tuoi commenti e suggerimenti sono molto apprezzati!

Se hai intenzione di renderizzare Y = f(X)solo i grafici, ti suggerisco di provare il seguente metodo.

I dati della curva vengono passati come dati di trama , rendendoli persistenti e consentendo, glTexSubImage2Dad esempio, aggiornamenti parziali . Se è necessario scorrere, è possibile persino implementare un buffer circolare e aggiornare solo alcuni valori per frame. Ogni curva viene renderizzata come un quad a schermo intero e tutto il lavoro viene svolto dal pixel shader.

I contenuti delle trame monocomponente potrebbero apparire così:

+----+----+----+----+
| 12 | 10 |  5 | .. | values for curve #1
+----+----+----+----+
| 55 | 83 | 87 | .. | values for curve #2
+----+----+----+----+

Il lavoro del pixel shader è il seguente:

• trova la coordinata X del frammento corrente nello spazio del set di dati
• prendere ad es. i 4 punti dati più vicini che hanno dati; per esempio se il valore X è 41.3lo avrebbe scelto 40, 41, 42e 43.
• interrogare la trama per i 4 valori Y (assicurarsi che il campionatore non esegua interpolazioni di alcun tipo)
• converti le X,Ycoppie nello spazio dello schermo
• calcola la distanza dal frammento corrente a ciascuno dei tre segmenti e quattro punti
• usa la distanza come valore alfa per il frammento corrente

Potresti voler sostituire 4 con valori maggiori a seconda del potenziale livello di zoom.

Ho scritto uno shader GLSL molto veloce e sporco implementando questa funzione . Potrei aggiungere la versione HLSL in seguito, ma dovresti essere in grado di convertirla senza troppi sforzi. Di seguito è possibile vedere il risultato, con diverse dimensioni di linea e densità di dati:

Un chiaro vantaggio è che la quantità di dati trasferiti è molto bassa e il numero di richiami è solo uno.

C'era un capitolo Gemme GPU sul rendering di linee antialias: Fast Prefiltered Lines . L'idea di base è di rendere ogni segmento di linea come un quadruplo e calcolare, ad ogni pixel, una funzione gaussiana della distanza del centro del pixel dal segmento di linea.

Questo significa disegnare ogni segmento di linea nel grafico come un quad separato, ma in D3D11 potresti certamente usare uno shader di geometria e / o istanza per generare i quad, riducendo la quantità di dati da trasferire alla GPU solo ai punti dati loro stessi. Probabilmente imposterei i punti dati come StructuredBuffer affinché vengano letti dallo shader vertice / geometria, quindi eseguo una chiamata di disegno specificando il numero di segmenti da disegnare. Non ci sarebbero veri e propri buffer di vertici; lo shader di vertici userebbe semplicemente SV_VertexID o SV_InstanceID per determinare quali punti dati guardare.

@ Dr.ABT - Ci scusiamo per questa è una domanda, non una risposta. Non ho trovato il modo di chiederlo nella risposta di Sam Hocevar sopra.

Potresti condividere maggiori dettagli su come hai finalmente implementato le linee per il tuo grafico? Ho lo stesso bisogno di un'app WPF. Grazie in anticipo per eventuali dettagli o codice che puoi condividere su questo.