Exceto o OpenGL, eu nunca usei essas bibliotecas, mas vou tentar adivinhar, lendo páginas da Wikipedia, como você fez.
Você parece certo sobre Mesa. Aqui estão as informações adicionais que temos:
"O sistema X window é um sistema de software e protocolo de rede que fornece uma GUI básica para computadores em rede. Cria uma camada de abstração de hardware".
"O GLX permite que programas que desejam usar o OpenGL façam isso em uma janela fornecida pelo Sistema X Window. O
GLX consiste em três partes:
- Uma API que fornece funções OpenGL.
- Uma extensão do protocolo X, que permite ao cliente enviar 3D comandos de renderização - Uma extensão do servidor X que recebe os comandos de renderização do cliente e os passa para a biblioteca OpenGL instalada.
Se o cliente e o servidor estiverem em execução no mesmo computador e uma placa gráfica 3D acelerada estiver disponível, os dois primeiros componentes poderão contornado pelo DRI. O programa cliente pode acessar diretamente o hardware gráfico ".
"A Direct Rendering Infrastructure (DRI) é uma interface usada no Sistema X Window para permitir que aplicativos do usuário acessem o hardware de vídeo sem exigir que os dados sejam transmitidos pelo servidor X".
"O Open Inventor é uma API gráfica 3D C ++ projetada para fornecer uma camada mais alta de programação para o OpenGL"
Para simplificar, vamos imaginar um fluxo simplificado de dados (e comandos) que acontece nas entradas e saídas de cada uma dessas APIs. No início, temos o seu aplicativo (código compilado), que você executa no seu computador. No final, temos imagens exibidas na tela.
Existem vários casos que restringirei às respostas a estas perguntas: - o
seu computador possui uma placa gráfica (GPU) ou apenas uma CPU para processar funções gráficas?
- seu aplicativo está incorporado em uma janela do sistema x-window?
-se você usa o sistema x window, o "servidor x" está sendo executado no seu computador ou em outro computador na rede?
Suponho que você tenha os drivers para sua GPU, se você tiver um, e que você tenha o Mesa para a renderização do software).
Primeiro cenário: você executa um aplicativo gráfico escrito com o OpenInventor, sem usar o Sistema X Window, e não possui uma placa gráfica. O fluxo do programa seria bastante semelhante 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
O que acontece aqui é chamado de "renderização de software": o comando graphics não é tratado por nenhum hardware gráfico, mas pela CPU usual, o processador que geralmente executa o software.
Segundo cenário: agora imagine que, com as mesmas condições acima, você tenha uma placa gráfica. O fluxo ficaria mais ou menos assim:
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
O que acontece agora é chamado de "aceleração de hardware", geralmente mais rápido que o primeiro cenário.
Terceiro cenário: agora vamos apresentar o fluxo do X Window System, ou pelo menos como eu penso, com base nas poucas linhas da Wikipedia que li.
Vamos esquecer o hardware gráfico e a API por um tempo. O fluxo deve se parecer com:
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
Observe que, ao usar o X Window System, a tela e o computador em que você executa o aplicativo podem não estar "diretamente" conectados, mas podem estar conectados através de uma rede.
Quarto cenário: suponha que você queira adicionar renderizações gráficas 3D sofisticadas ao seu aplicativo X Client do exemplo anterior. Parece-me que o X Window System não é capaz de fazer isso originalmente, ou pelo menos seria necessário muito código complicado para executar o equivalente a uma função da API do OpenGL.
Felizmente, você pode usar o GLX para adicionar suporte aos comandos do OpenGL no sistema. Agora você tem:
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)
...
Agora você pode reconectar a última seta àquela após "OpenGL" no primeiro cenário: você pode obter imagens em 3D na tela!
Finalmente, sobre o que eu acho que entende do DRI:
parece permitir que o Mesa tenha acesso à GPU, de modo que modificaria o fluxo do nosso primeiro cenário para:
...
↓
Mesa
↓ (forwards OpenGL commands)
DRI
↓ (converts OpenGL commands to GPU commands)
Graphic Card
↓
3D Images on your screen
E também parece causar um curto-circuito no fluxo ao usar o GLX, considerando a condição de que o servidor e o cliente estejam no mesmo computador e que você tenha uma GPU. Nesse caso, o gráfico do nosso quarto cenário se tornaria simplesmente:
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
É isso aí !
Agora, lembre-se de que eu não sou especialista em ambientes Unix, portanto, meu melhor conselho é estudar a documentação de cada uma dessas APIs para saber exatamente o que elas podem fazer.
Combinar o gráfico anterior em um único pode facilitar a compreensão das coisas. Eu deixei isso como um exercício para você!