¿Qué versión (es) de OpenGL para aprender y / o usar?

Entonces, soy nuevo en OpenGL ... Tengo un conocimiento general de programación de juegos pero poca experiencia práctica.

He estado buscando en varios artículos y libros e intentando sumergirme en OpenGL, pero he encontrado confusas las diversas versiones y la forma antigua y nueva de hacer las cosas.

Creo que mi primera pregunta es si alguien conoce algunas cifras sobre los porcentajes de jugadores que pueden ejecutar cada versión de OpenGL. ¿Cómo es la cuota de mercado? 2.x, 3.x, 4.x ...

Investigué los requisitos para Half Life 2, ya que sé que Valve lo actualizó con OpenGL para que se ejecute en Mac y sé que generalmente intentan alcanzar una base de usuarios muy amplia, y dicen un mínimo de GeForce 8 Series. Miré el 8800 GT en el sitio web de Nvidia y enumeró el soporte para OpenGL 2.1. Lo cual, tal vez me equivoque, me suena antiguo ya que ya hay 4.x. ¡Busqué un controlador para 8800GT y dice que es compatible con 4.2! Un poco de discrepancia allí, jajaja.

También he leído cosas como XP solo admite hasta una determinada versión, o OS X solo admite 3.2, o todo tipo de otras cosas. En general, estoy confundido acerca de cuánto soporte hay para varias versiones y qué versión aprender / usar.

También estoy buscando recursos de aprendizaje. Mis resultados de búsqueda hasta ahora me han señalado a OpenGL SuperBible. La cuarta edición tiene excelentes críticas en Amazon, pero enseña 2.1. La quinta edición enseña 3.3 y hay un par de cosas en las revisiones que mencionan que la cuarta edición es mejor y que la quinta edición no enseña correctamente las nuevas características o algo así. Básicamente, incluso dentro del material de aprendizaje, veo discrepancias y ni siquiera sé por dónde empezar.

Por lo que entiendo, 3.x comenzó una forma completamente nueva de hacer las cosas y he leído de varios artículos y reseñas que quieres "mantenerte alejado de las funciones obsoletas como glBegin (), glEnd ()" pero muchos libros y tutoriales que he visto usar ese método. He visto a gente decir que, básicamente, la nueva forma de hacer las cosas es más complicada pero la vieja forma es mala>.>

Solo una nota al margen, personalmente, sé que todavía tengo mucho que aprender de antemano, pero estoy interesado en la teselación; así que supongo que eso también tiene en cuenta eso, porque, hasta donde yo entiendo, ¿eso es solo en 4.x?

[solo por cierto, mi escritorio es compatible con 4.2]

Si se está preguntando acerca de la cobertura de OpenGL, un buen lugar para comenzar es la Encuesta de hardware de Steam.

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

Desafortunadamente, parece estar roto en este momento y no muestra ninguna estadística para las tarjetas de video. : \

También he leído cosas como XP solo admite hasta una versión determinada

DirectX 9 es comparable a OpenGL 2.1, DirectX 10 a OpenGL 3.0 y DirectX 11 a OpenGL 4.0. Aquí es de donde surge la confusión.

XP es compatible con todas las versiones de OpenGL, pero no es compatible con DirectX 10 o superior. Así es como Microsoft quería obligar a las personas a actualizar a Vista, pero no funcionó muy bien. OpenGL es un estándar abierto, por lo que siempre que los fabricantes de tarjetas de video estén dispuestos a producir controladores para XP, admitirá versiones más nuevas de OpenGL.

Por lo que entiendo, 3.x comenzó una forma completamente nueva de hacer las cosas y he leído de varios artículos y reseñas que quieres "mantenerte alejado de las funciones obsoletas como glBegin (), glEnd ()" pero muchos libros y tutoriales que he visto usar ese método. He visto a gente decir que, básicamente, la nueva forma de hacer las cosas es más complicada pero la vieja forma es mala>.>

Este es un gran problema para OpenGL. Básicamente, en los viejos tiempos, enviabas cosas a la tarjeta de video usando el "modo inmediato". Comience con glBegin, haga algunas cosas, termine con glEnd. Sin embargo, a los controladores de tarjetas de video no les gusta esto en absoluto . ¿Cómo pueden saber cuántas cosas vas a enviar? ¿Serán 4 vértices para un quad texturizado o 100,000 para un modelo con piel? Esta es la razón por la que introdujeron objetos de búfer de vértices (VBO). Si bien el modo inmediato es una lista vinculada, un VBO es una matriz estática. El desarrollador sabe qué tan grande es, el controlador sabe qué tan grande es. Todos están felices. Entonces, la junta de estándares de OpenGL (Grupo Khronos) decidió desaprobar el modo inmediato para OpenGL 3.0 y versiones posteriores. Sin embargo, esto es problemático, como lo mostraré con un simple ejemplo.

Digamos que desea mostrar un quad con textura, comenzando desde cero.

En OpenGL 2.1:

• Configure la matriz de proyección y colóquela GL_PROJECTION.
• Configure la matriz modelview y colóquela GL_MODELVIEW.
• Cargue una imagen y póngala en un GL_TEXTURE_2Dasa.
• Defina las posiciones, coordenadas de textura y colores para sus vértices.
• Unir la textura.
• glBegin... glVertex2f... glTexCoord2f... glEnd.

En OpenGL 3.0:

• Construya una matriz para proyección y vista de modelo.
• Cargue una imagen y póngala en un GL_TEXTURE_2Dasa.
• Defina las posiciones, coordenadas de textura y colores para sus vértices y colóquelos en VBO.
• Cree un objeto de matriz de vértices (VAO) y adjunte sus VBO.
• Escriba un sombreador para generar un quad con textura y póngalo en un programa de sombreador.
• Adjunte las matrices al programa de sombreado con uniformes.
• Unir la textura.
• Adjunte la textura al programa de sombreado.
• glDrawArrays.

Entonces, ¿qué podría salir mal en la primera versión?

• Tus posiciones son incorrectas.
• Su vértice sinuoso está al revés.
• Tu textura no se carga correctamente.
• Tu textura no se une correctamente.
• Su matriz de proyección está mal.
• Su matriz de vista de modelo está mal.
• No estás enviando los vértices correctos.

Y en la segunda versión, puede tener problemas con lo anterior y :

• Tus VBO están equivocados.
• Tu VAO está mal.
• Tu sombreador está mal.
• Su textura de unión al sombreador está mal.

Sin las herramientas de depuración adecuadas, esto se convierte en un problema grave. Esta es la razón por la cual la gente dice que debes quedarte en modo inmediato Afortunadamente, ahora tenemos el gDEBugger gratuito y excelente , pero no es una bala mágica.

Para responder a tu pregunta: depende de tu juego. Si desea llegar a un público amplio (por ejemplo, un juego casual o un juego de plataformas en 2D), debe apuntar a 2.1. Si de todos modos está haciendo un juego espacial épico que no se ejecutará en hardware de seis años, objetivo 3.3. Y si necesita lo último y lo mejor para compatibilidad futura, apunte a 4.0.

Para algunas estadísticas sobre compatibilidad de hardware, puede consultar la encuesta de Steam: http://store.steampowered.com/hwsurvey/ Aunque enumera DX10 y DX11, la compatibilidad de hardware es la misma que OpenGL 3 y OpenGL 4 respectivamente. Sin embargo, tenga en cuenta que el estado de instalación del controlador OpenGL en las personas suele ser peor que DX.

Windows XP no es compatible con DX10 o DX11, pero OpenGL 3 y 4 deberían estar bien, siempre que los controladores estén bien. OSX admite OpenGL 3 (como máximo), en Linux obtienes OpenGL 4 con controladores de proveedores ATI / NVIDIA (por supuesto, solo si el hardware lo admite).

Luego también están las versiones ES móviles de OpenGL. De hecho, sugeriría buscar OpenGL ES 2.0, porque es más pequeño, es más fácil de aprender, pero también necesita usar prácticas modernas, es decir, sombreadores y VBO. También es lo que se usa en la mayoría de los dispositivos móviles (por lo que podría comenzar a hacer juegos móviles) y también WebGL es básicamente lo mismo, por lo que en realidad podría aprender todo en el navegador web con sus ventajas de desarrollo rápido. OpenGL ES 3.0 se lanzará este verano.

Tessellation es una característica de OpenGL 4.0. Primero debe aprender los otros tipos de sombreadores, y mucho menos todos los conceptos básicos, pero estoy de acuerdo en que es interesante; de ​​hecho, he escrito una pequeña prueba con él: http://blog.tapiov.net/post/15189341463/playing- con-opengl-4-teselación