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

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]

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.

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