John Carmack

Un article de Wikipédia, l'encyclopédie libre.

Vous avez de nouveaux messages (diff^?).

John Carmack en 2005
Prise de vue : Spaceman Spiffy

John Carmack (né le 20 août 1970) est le programmeur principal et le co-fondateur (avec plusieurs personnes, dont John Romero) de la société id Software, une entreprise de développement de jeux vidéo. Son habileté en programmation informatique lui a permis de devenir une célébrité dans la communauté des joueurs.

Le premier jeu développé par id Software, fut Commander Keen. John Carmack est à l'origine de nombreux jeux de tir subjectifs tels que : Wolfenstein 3D, Doom et Quake, qui plongent le joueur dans un univers en trois dimensions et le mettent dans la peau d'un personnage belliqueux. Plus récemment, il a développé Doom 3 dont le moteur graphique est à la pointe de la technologie actuelle. Il a inventé plusieurs algorithmes (dont le Carmack's Reverse qu'il n'est pas en fait le premier à imaginer), et il a été le premier à développer des moteurs graphiques capables d'exploiter au maximum les évolutions du matériel, en particulier des cartes graphiques pour PC, pour la génération d'images 3D en système temps réel. Quake a aussi innové grâce à la possibilité de jouer à plusieurs en temps réel, par le biais d'Internet.

En 2001, il a rejoint le panthéon des développeurs (Hall of Fame) de l'Académie des Arts et des Sciences Interactifs.

Amateur de fusées, il est fondateur de la société Armadillo Aerospace.

[modifier] 0x5f3759df

Quake 3 Arena étant sous license GPL, il est possible de consulter l'intégralité du code source de ce jeu. Parmi celui-ci, on retrouve deux fonctions écrites par John Carmack et qui auront fait beaucoup parler d'elles : l'une pour calculer une racine carrée, l'autre pour calculer l'inverse d'une racine carrée.

Écrites en C, ces fonctions sont respectivement les suivantes :

 float SquareRootFloat(float number){
   long i;
   float x, y;
   const float f = 1.5F;
   
   x = number * 0.5F;
   y  = number;
   i  = * ( long * ) &y;
   i  = 0x5f3759df - ( i >> 1 );
   y  = * ( float * ) &i;
   y  = y * ( f - ( x * y * y ) );
   y  = y * ( f - ( x * y * y ) );
   return number * y;
 }

 float Q_rsqrt( float number ){
   long i;
   float x2, y;
   const float threehalfs = 1.5F;
   
   x2 = number * 0.5F;
   y  = number;
   i  = * ( long * ) &y;  // evil floating point bit level hacking
   i  = 0x5f3759df - ( i >> 1 ); // what the fuck?
   y  = * ( float * ) &i;
   y  = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration
   // y  = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed
   
   #ifndef Q3_VM
   #ifdef __linux__
     assert( !isnan(y) ); // bk010122 - FPE?
   #endif
   #endif
   return y;
 }

Ces fonctions sont pour le moins particulières puisqu'elles ne contiennent aucune boucle, elles ne font intervenir qu'une suite de calculs élémentaires! Pour autant, celles-ci fournissent des approximations tout à fait acceptables (de l'ordre de 10^-3). Elles sont même jusqu'à 4 fois plus rapides que la fonction sqrt(float x) et se révèlent ainsi parfaites pour un jeu vidéo.

En réalité, ces deux fonctions reposent sur une méthode tirée de l'analyse numérique : la méthode de Newton. La clef de leur efficacité réside dans l'utilisation d'une constante particulière 0x5f3759df. Cette constante est utilisée comme première approximation et réduit de façon remarquable le nombre d'itérations nécessaires pour obtenir une approximation satisfaisante. Cette constante — dite magique — est si remarquable qu'une seule itération est en fait nécessaire!

Chris Lomont de l'université de Purdue a depuis étudié la question. Il existe une constante fournissant de meilleures approximations : 0x5f375a86. Dans son étude, Chris Lomont fait également mention du fait que l'utilisation originale de cette constante serait peut-être dûe à Gary Tarolli, alors développeur chez nVidia.