Tranne OpenGL, non ho mai usato quelle librerie, ma cercherò di indovinare, leggendo le pagine di Wikipedia, come hai fatto tu.
Sembri giusto su Mesa. Ecco le informazioni aggiuntive che abbiamo:
"Il sistema X Window è un sistema software e un protocollo di rete che fornisce una GUI di base per i computer in rete. Crea un livello di astrazione hardware."
"GLX consente ai programmi che desiderano utilizzare OpenGL di farlo all'interno di una finestra fornita da X Window System.
GLX è costituito da tre parti:
- Un'API che fornisce funzioni OpenGL.
- Un'estensione del protocollo X, che consente al client di inviare 3D comandi di rendering - Un'estensione del server X che riceve i comandi di rendering dal client e li trasmette alla libreria OpenGL installata
Se client e server sono in esecuzione sullo stesso computer ed è disponibile una scheda grafica 3D accelerata, i due componenti precedenti possono essere bypassato dal DRI. Il programma client può quindi accedere direttamente all'hardware grafico. "
"Direct Rendering Infrastructure (DRI) è un'interfaccia utilizzata nel sistema X Window per consentire alle applicazioni degli utenti di accedere all'hardware video senza richiedere il passaggio dei dati attraverso il server X."
"Open Inventor è un'API grafica 3D C ++ progettata per fornire un livello superiore di programmazione per OpenGL"
Per semplificare le cose, immaginiamo un flusso semplificato di dati (e comandi) che si verifica alle voci e alle uscite di ciascuna di queste API. All'inizio abbiamo il tuo programma applicativo (codice compilato), che esegui dal tuo computer. Alla fine abbiamo immagini che vengono visualizzate sul tuo schermo.
Esistono diversi casi che trattengo dalle risposte a queste domande:
-il tuo computer ha una scheda grafica (GPU), o solo una CPU, per elaborare le funzioni grafiche?
-la tua applicazione è integrata in una finestra del sistema x-window?
-se usi il sistema x window, il "x server" è in esecuzione sul tuo computer o su un altro computer in rete?
Presumo che tu abbia i driver per la tua GPU se ne hai uno e che tu abbia Mesa per il rendering del software).
Primo scenario: esegui un'applicazione grafica scritta con OpenInventor, senza utilizzare il sistema X Window e non hai una scheda grafica. Il flusso del programma sarebbe abbastanza simile a:
Your application
↓ (uses functions of)
OpenInventor
↓ (calls functions declared by)
OpenGL
↓ (redirects function calls to implementation defined by)
Mesa
↓ (implemented OpenGL functions to be run on the CPU)
[Probably] Operating System rendering API
↓
3D Images on your screen
Quello che succede qui si chiama "rendering software": i comandi grafici non sono gestiti da alcun hardware grafico, ma invece dalla tua solita CPU, il processore che generalmente esegue il software.
Secondo scenario: ora immagina che con le stesse condizioni di cui sopra, hai una scheda grafica. Il flusso sarebbe più simile a questo:
Your application
↓ (uses functions of)
OpenInventor
↓ (calls functions declared by)
OpenGL
↓ (redirects function calls to implementation defined by)
Proprietary Drivers
↓ (converts OpenGL commands to GPU commands)
Graphic Card
↓
3D Images on your screen
Quello che succede ora si chiama "accelerazione hardware", di solito più veloce del primo scenario.
Terzo scenario: ora introduciamo il flusso di X Window System, o almeno come penso, basato sulle poche righe di Wikipedia che ho letto.
Dimentichiamoci dell'hardware grafico e dell'API per un po '. Il flusso dovrebbe apparire come:
Your application (X Window System sees it as an "X Client")
↓ (sends requests defined by the X Window System Core Protocol)
X Server
↓ (convert your request to graphic commands)
[Probably] Operating System rendering API
↓
Windows or 2D images on your screen
Si noti che quando si utilizza X Window System, lo schermo e il computer da cui si esegue l'applicazione potrebbero non essere "direttamente" connessi, ma potrebbero essere collegati attraverso una rete.
Quarto scenario: supponiamo di voler aggiungere fantasiosi rendering grafici 3D all'applicazione X Client dell'esempio precedente. Mi sembra che il sistema X Window inizialmente non sia in grado di farlo, o almeno richiederebbe molto codice contorto per eseguire l'equivalente di una funzione API OpenGL.
Fortunatamente puoi usare GLX per aggiungere supporto per i comandi OpenGL al sistema. Ora hai:
Your application
↓ (sends graphic requests defined by the "GLX extension to the X Protocol")
X Server with the GLX extension
↓ (convert your request to OpenGL commands)
OpenGL
↓ (redirects function calls to implementation defined by)
...
Ora puoi ricollegare l'ultima freccia a quella dopo "OpenGL" nel primo scenario: puoi ottenere immagini 3D sul tuo schermo!
Infine su ciò che penso capisca del DRI:
sembra consentire a Mesa di avere accesso alla GPU, in modo da modificare il flusso del nostro primo scenario in:
...
↓
Mesa
↓ (forwards OpenGL commands)
DRI
↓ (converts OpenGL commands to GPU commands)
Graphic Card
↓
3D Images on your screen
E sembra anche cortocircuitare il flusso quando si utilizza GLX, data la condizione che il suo server e client si trovino sullo stesso computer e che si disponga di una GPU. In tal caso, il grafico del nostro quarto scenario diventerebbe semplicemente:
Your application
↓ (sends graphic requests defined by the "GLX extension to the X Protocol")
DRI
↓ ("catches" OpenGL commands and converts them to GPU commands)
Graphic Card
↓
3D Images on your screen
Questo è tutto !
Ora tieni presente che non sono un esperto in ambienti Unix, quindi il mio miglior consiglio è di studiare la documentazione di ciascuna di queste API per sapere esattamente cosa possono fare.
La combinazione del grafico precedente in uno singolo potrebbe rendere le cose più facili da capire. Ho lasciato questo come esercizio per te!