Latest article: Exporter des données depuis Excel

Obtenir des infos sur la carte graphique avec OpenGL

Comment récupérer des informations comme le modèle, les extensions ou le support des shaders d’une carte graphique avec l’API OpenGL

Quand on travaille avec OpenGL, on a souvent besoin d’obtenir des infos sur la carte graphique, notamment la liste des extensions supportées.

On va donc voir comment récupérer le vendeur, le modèle de la carte graphique, une liste d’extensions et déterminer la version des shader models implémentée.

Toute se fait au travers de la fonction glGetString.

glGetString renvoit une chaine de caractère contenant des informations fournies par le driver de la carte graphique :

  • GL_VENDOR : le vendeur de la carte graphique (ex: NVidia, ATI ou Intel)
  • GL_RENDERER : le modèle exact de la carte graphique (ex: GeForce 8600 GT)
  • GL_VERSION : la version d’OpenGL utilisée (ex: 2.0)
  • GL_EXTENSIONS : une liste d’extensions séparées par des espaces

Récupérer la liste des extensions

C’est surtout cette liste d’extensions qui nous intéresse, mais elle est difficilement exploitable en l’état, on va voir comment se faciliter la vie :

std::set Extensions;

std::string ext = std::string ( (const char*)glGetString ( GL_EXTENSIONS ) );

std::string extension = "";
for ( std::size_t i = 0; i < ext.size(); ++i )
{
	const char& c = ext[i];
	if ( c != ' ' )
		extension += c;
	else
	{
		Extensions.insert ( extension );
		extension = "";
	}
}

Ce code va parcourir la chaine de caractère et rajouter chaque extension dans un std::set.

Pour savoir si une extension est supportée, il ne nous reste plus qu’a vérifier qu’elle est présente dans le set :

bool CheckExtension ( const std::string& extension ) const
{
	return ( Extensions.find ( extension ) != Extensions.end() );
}

On peut désormais tester la présence d’une extension facilement.

Déterminer la présence des shaders GLSL

Les shaders GLSL permettent de programmer la carte graphique à l’aide d’un langage haut niveau similaire au C (voir Les shaders GLSL avec Irrlicht et Cel Shading en GLSL).

Pour déterminer si ces shaders sont disponibles, il faut vérifier la présence de quatre extensions :

  • GL_ARB_shading_language_100
  • GL_ARB_shader_objects
  • GL_ARB_vertex_shader
  • GL_ARB_fragment_shader
bool CheckGLSLSupport () const
{
	return (
		CheckExtension( "GL_ARB_shading_language_100" ) && CheckExtension( "GL_ARB_shader_objects"       ) &&
		CheckExtension( "GL_ARB_vertex_shader"        ) && CheckExtension( "GL_ARB_fragment_shader"      ));
}

Déterminer la version des shader models

Il n’y a malheureusement aucune fonction directe pour déterminer le niveau de shader models.

Cependant, a chaque niveau de shaders models correspondent des extensions particulières :

  • SM 4:
    • GL_NV_gpu_program4
    • GL_NV_geometry_program4
    • GL_NV_vertex_program4
    • GL_NV_fragment_program4
    • GL_EXT_gpu_shader4
    • GL_EXT_geometry_shader4
  • SM 3:
    • GL_NV_vertex_program3
    • GL_NV_fragment_program2
    • GL_ATI_shader_texture_lod

Si vous n’avez ni les SM3 ni les SM4, mais que les shaders GLSL sont disponibles, alors vous avez les shader models 2.

Pour résumer :

int GetShaderModel () const
{
	if (
			CheckExtension("GL_NV_gpu_program4"			) ||
			CheckExtension("GL_NV_geometry_program4"	) ||
			CheckExtension("GL_NV_vertex_program4"		) ||
			CheckExtension("GL_NV_fragment_program4" 	) ||
			CheckExtension("GL_EXT_gpu_shader4"		 	) ||
			CheckExtension("GL_EXT_geometry_shader4"	)
		)
	{
		return 4;
	}
	else if (
				CheckExtension("GL_NV_vertex_program3"		) ||
				CheckExtension("GL_NV_fragment_program2"	) ||
				CheckExtension("GL_ATI_shader_texture_lod"	)
			)
	{
		return 3;
	}
	else if ( HasGLSLSupport() )
	{
		return 2;
	}
	else
	{
		return 0;
	}
}

Et voilà !

Maintenant vous disposez d’un petit arsenal pour mieux détecter les spécificités de la carte graphique, et adapter votre application en conséquence.

Discussion

Reply