Quais versões do OpenGL aprendem e / ou usam?

16

Então, eu sou novo no OpenGL ... Tenho conhecimentos gerais de programação de jogos, mas pouca experiência prática.

Estive pesquisando vários artigos e livros e tentando mergulhar no OpenGL, mas achei as várias versões e a maneira antiga e nova de fazer as coisas confusas.

Acho que minha primeira pergunta é: alguém conhece algumas cifras sobre porcentagens de jogadores que podem rodar cada versão do OpenGL. Como é a participação de mercado? 2.x, 3.x, 4.x ...

Examinei os requisitos do Half Life 2, pois sei que a Valve o atualizou com o OpenGL para rodar no Mac e sei que eles geralmente tentam atingir uma base de usuários muito ampla e dizem o mínimo da GeForce 8 Series. Eu olhei para o 8800 GT no site da Nvidia e ele listou o suporte ao OpenGL 2.1. O que, talvez eu esteja errado, parece antigo para mim, já que já existe o 4.x. Procurei um driver para 8800GT e ele diz que suporta 4.2! Um pouco de discrepância lá, lol.

Também li coisas como o XP suporta apenas até uma determinada versão, ou o OS X suporta apenas 3.2 ou todos os tipos de outras coisas. No geral, estou confuso quanto ao suporte para várias versões e qual versão aprender / usar.

Também estou procurando recursos de aprendizado. Até agora, meus resultados de pesquisa me indicaram o OpenGL SuperBible. A 4ª edição tem ótimas críticas na Amazon, mas ensina 2.1. A 5ª edição ensina 3.3 e há algumas coisas nas resenhas que mencionam que a 4ª edição é melhor e que a 5ª edição não ensina adequadamente os novos recursos ou algo assim? Basicamente, mesmo no material de aprendizado, vejo discrepâncias e nem sei por onde começar.

Pelo que entendi, o 3.x iniciou uma maneira totalmente nova de fazer as coisas e li em vários artigos e resenhas que você deseja "ficar longe de recursos obsoletos, como glBegin (), glEnd ()", mas muitos livros e tutoriais que eu já vi usar esse método. Já vi pessoas dizendo que, basicamente, a nova maneira de fazer as coisas é mais complicada, mas a velha é ruim>.>

Apenas uma observação: pessoalmente, eu sei que ainda tenho muito a aprender de antemão, mas estou interessado em mosaico; então eu acho que isso também é importante, porque, até onde eu entendo, isso é apenas na versão 4.x?

[apenas, meu desktop suporta 4.2]

Kenmore
fonte
Esta questão (no estouro de pilha) parece ser uma duplicata: stackoverflow.com/questions/6823371/…
Anderson Green

Respostas:

21

Se você está se perguntando sobre a cobertura do OpenGL, um bom lugar para começar é a Pesquisa de Hardware do Steam.

http://store.steampowered.com/hwsurvey?platform=pc

Infelizmente, parece estar quebrado no momento e não exibe estatísticas para cartões de vídeo. : \

Eu também li coisas como o XP suporta apenas até uma certa versão

O DirectX 9 é comparável ao OpenGL 2.1, DirectX 10 ao OpenGL 3.0 e DirectX 11 ao OpenGL 4.0. É aí que a confusão se origina.

O XP suporta todas as versões do OpenGL, mas não suporta o DirectX 10 ou superior. Foi assim que a Microsoft quis forçar as pessoas a atualizar para o Vista, mas não funcionou muito bem. O OpenGL é um padrão aberto; portanto, enquanto os fabricantes de placas de vídeo estiverem dispostos a produzir drivers para o XP, ele oferecerá suporte a versões mais recentes do OpenGL.

Pelo que entendi, o 3.x iniciou uma maneira totalmente nova de fazer as coisas e li em vários artigos e resenhas que você deseja "ficar longe de recursos obsoletos, como glBegin (), glEnd ()", mas muitos livros e tutoriais que eu já vi usar esse método. Já vi pessoas dizendo que, basicamente, a nova maneira de fazer as coisas é mais complicada, mas a velha é ruim>.>

Este é um problema muito grande para o OpenGL. Basicamente, antigamente, você enviava coisas para a placa de vídeo usando o "modo imediato". Comece com glBegin, faça algumas coisas, termine com glEnd. No entanto, drivers da placa de vídeo não gostam deste em tudo . Como eles podem saber quantas coisas você vai enviar? Serão 4 vértices para um quad texturizado ou 100.000 para um modelo com skin? É por isso que eles introduziram objetos de buffer de vértices (VBO's). Enquanto o modo imediato é uma lista vinculada, um VBO é uma matriz estática. O desenvolvedor sabe quão grande é, o motorista sabe quão grande é. Todo mundo está feliz. Portanto, o conselho de padrões do OpenGL (Khronos Group) decidiu descontinuar o modo imediato para o OpenGL 3.0 e superior. No entanto, isso é problemático, como mostrarei com um exemplo simples.

Digamos que você queira exibir um quad texturizado, começando do zero.

No OpenGL 2.1:

  • Configure a matriz de projeção e coloque-a GL_PROJECTION.
  • Configure a matriz modelview e insira-a GL_MODELVIEW.
  • Carregue uma imagem e coloque-a em uma GL_TEXTURE_2Dalça.
  • Defina as posições, coordenadas de textura e cores para seus vértices.
  • Vincule a textura.
  • glBegin... glVertex2f... glTexCoord2f... glEnd.

No OpenGL 3.0:

  • Crie uma matriz para projeção e modelview.
  • Carregue uma imagem e coloque-a em uma GL_TEXTURE_2Dalça.
  • Defina as posições, coordenadas de textura e cores dos seus vértices e coloque-os nos VBOs.
  • Crie um objeto de matriz de vértice (VAO) e anexe seus VBO.
  • Escreva um shader para produzir um quad texturizado e coloque-o em um programa de shader.
  • Anexe as matrizes ao programa shader usando uniformes.
  • Vincule a textura.
  • Anexe a textura ao programa shader.
  • glDrawArrays.

Então, o que poderia dar errado na primeira versão?

  • Suas posições estão incorretas.
  • Seu enrolamento de vértice é o contrário.
  • Sua textura não carrega corretamente.
  • Sua textura não se liga adequadamente.
  • Sua matriz de projeção está errada.
  • Sua matriz modelview está errada.
  • Você não está enviando os vértices certos.

E na segunda versão, você pode ter problemas com os itens acima e :

  • Seus VBO's estão errados.
  • Seu VAO está errado.
  • Seu shader está errado.
  • A ligação da sua textura ao shader está errada.

Sem as ferramentas de depuração adequadas, isso se torna um problema sério. É por isso que as pessoas dizem que você deve manter o modo imediato. Felizmente, agora temos o gDEBugger gratuito e excelente agora, mas não é uma bala mágica.

Para responder sua pergunta: depende do seu jogo. Se você deseja alcançar um público amplo (por exemplo, um jogo casual ou um jogo de plataformas 2D), deve atingir o 2.1. Se você estiver criando um jogo espacial épico que não será executado em hardware de seis anos, mire no 3.3. E se você precisar dos melhores e mais recentes para compatibilidade futura, segmente 4.0.

knight666
fonte
2
Acho que você está mostrando algum viés contra o VAO / VBO aqui. Na realidade, se você quisesse desenhar um quad texturizado, teria um conjunto VAO / VBO completo, juntamente com sombreadores e texturas já criados (durante a inicialização do programa - ninguém os cria em tempo de execução). Desenhar um quad texturizado através da nova maneira é, na realidade, apenas um punhado de chamadas - é verdade que carrega a complexidade no início do programa, enquanto a maneira antiga expõe a complexidade no tempo de execução.
Maximus Minimus
2
Mas foi exatamente isso que eu quis dizer: agora seu bug pode estar em seus dados (dados de vértice e objeto de textura), seu programa de sombreador, seu código de sombreador, suas matrizes, seu upload uniforme ou sua ligação VAO. Se você começar do nada , há muitos subsistemas para verificar! E você tem que acompanhar muito mais o estado.
Julio
1
Observe que o gDEBugger do site gremedy está desatualizado. Presumo abandonado, já que seus fóruns estão desativados há muito tempo. A ferramenta foi escolhida pela AMD: gDEBugger .
MichaelHouse
2
"glBegin ... glVertex2f ... glTexCoord2f ... glEnd." Apenas não. glBegin, glVertex etc. nunca estiveram certos. O glDrawArrays foi introduzido no OpenGL 1.1 (1997) e deve sempre ser usado no glBegin e End.
API-Beast
9

Para algumas estatísticas sobre compatibilidade de hardware, você pode consultar a pesquisa Steam: http://store.steampowered.com/hwsurvey/ Apesar de listar o DX10 e o DX11, a compatibilidade do hardware é a mesma do OpenGL 3 e OpenGL 4, respectivamente. Porém, observe que o estado de instalação do driver OpenGL nas pessoas geralmente é pior que o DX.

O Windows XP não suporta DX10 ou DX11, mas o OpenGL 3 e 4 deve estar bem, desde que os drivers estejam ok. O OSX suporta o OpenGL 3 (no máximo); no Linux, você obtém o OpenGL 4 com drivers de fornecedores da ATI / NVIDIA (é claro, apenas se o hardware o suportar).

Depois, há também as versões ES móveis do OpenGL. Na verdade, eu sugiro olhar para o OpenGL ES 2.0, porque é menor, mais fácil de aprender, mas você também precisa usar práticas modernas, como shaders e VBOs. É também o que é usado na maioria dos dispositivos móveis (para que você possa criar jogos para celular) e o WebGL é basicamente o mesmo, para que você possa realmente aprender todo o aprendizado no navegador da Web com suas vantagens de desenvolvimento rápido. O OpenGL ES 3.0 será lançado neste verão.

O mosaico é um recurso do OpenGL 4.0. Você deve primeiro aprender os outros tipos de shaders, sem falar no básico, mas eu concordo que é interessante - na verdade, escrevi um pequeno teste com ele: http://blog.tapiov.net/post/15189341463/playing- com-opengl-4-mosaico

Tapio
fonte
4
Porra, knight666 me venceu, com uma resposta mais detalhada. Ainda assim, vale a pena pensar na parte ES.
Tapio