Magnum : un nouveau moteur graphique 2D/3D multiplateforme
Modulaire, utilisant les avantages du C++11 pour faciliter l'utilisation d'OpenGL

Le , par LittleWhite, Responsable 2D/3D/Jeux
Magnum, un nouveau moteur graphique 2D/3D multiplateforme
Un moteur graphique modulaire écrit en C++11 et utilisant OpenGL

Au début, Magnum n'était qu'un simple « wrapper » visant à simplifier les opérations sur les vecteurs et les matrices. Au fur et à mesure, celui-ci a évolué pour devenir un véritable moteur graphique simplifiant l'accès au développement d'applications graphiques bas niveau avec OpenGL et profitant des avantages qu'apporte la nouvelle version du C++.

Actuellement, Magnum supporte :
  • OpenGL 2.1 à 4.4, que ce soit les fonctionnalités du cœur ou des extensions ;
  • OpenGL ES 2.0, 3.0 et leurs extensions ;
  • Linux et Linux embarqué (soit à travers GLX/EGL, Xlib ou encore GLUT ou la SDL 2) ;
  • Windows (grâce à GLUT et SDL 2) ;
  • Google Chrome (grâce au native client).


La bibliothèque utilise intensivement le C++11 pour vous simplifier la vie :

  • durant l'initialisation :
    • en C++03
      Code : Sélectionner tout
      1
      2
      3
      4
      5
      6
      Int* data = new Int{2, 5, -1, 10, 0,                           
                          3, 53, -60, -27, // oops 
                          9, 0, 4, 7, 135}; 
        
      Math::Matrix<3, 5, Int> a; 
      a.assignFrom(data);
    • en C++11
      Code : Sélectionner tout
      1
      2
      3
      Math::Matrix<3, 5, Int> a({2, 5, -1, 10, 0},                  
                                {3, 53, -60, -27, 25}, 
                                {9, 0, 4, 7, 135});
  • pour les unités :
    • En C++03 :
      Code : Sélectionner tout
      1
      2
      3
      Object3D object;                                          
      object.translate(Vector3(1.5f, 0.3f, -1.0f)) 
          .rotate(35.0f); // cette fonction accepte des degrées, n'est ce pas ?
    • En C++11 :
      Code : Sélectionner tout
      1
      2
      3
      Object3D object; 
      object.translate({1.5f, 0.3f, -1.0f}) 
          .rotate(35.0_degf);
  • dans la facilité d'écrire du code :
    • En C++03 et OpenGL pur
      Code : Sélectionner tout
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      const int SHADER_POSITION = 0; // three-component 
      const int SHADER_NORMAL = 1; // three-component 
      const int SHADER_TEXCOORDS = 2; // two-component 
      const int SHADER_WEIGHT = 3; // one-component 
        
      /* Configuration du mesh */ 
      glEnableVertexAttribArray(SHADER_POSITION); 
      glEnableVertexAttribArray(SHADER_NORMAL); 
      glEnableVertexAttribArray(SHADER_TEXCOORDS); 
      glEnableVertexAttribArray(SHADER_WEIGHT); 
        
      glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer); 
      int offset = 4238; 
      glVertexAttribPointer(SHADER_POSITION, 3, GL_FLOAT, GL_FALSE, 40, static_cast<GLvoid*>(offset)); 
      glVertexAttribPointer(SHADER_NORMAL, 3, GL_FLOAT, GL_FALSE, 40, static_cast<GLvoid*>(offset + 12)); 
      glVertexAttribPointer(SHADER_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 40, static_cast<GLvoid*>(offset + 24)); 
      glVertexAttribPointer(SHADER_WEIGHT, 2, GL_FLOAT, GL_FALSE, 40, static_cast<GLvoid*>(offset + 32)); // oops
    • Avec le C++11 et Magnum :
      Code : Sélectionner tout
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
       
      class Shader: public AbstractShaderProgram { 
          public: 
              typedef Attribute<0, Vector3> Position; 
              typedef Attribute<1, Vector2> Normal; 
              typedef Attribute<2, Vector3> TextureCoordinates; 
              typedef Attribute<3, Float> Weight; 
        
          // ... 
      }; 
        
      /* Configuration du mesh */ 
      Buffer vertexBuffer; 
      Mesh mesh; 
      mesh.addVertexBuffer(vertexBuffer, 4238, Shader::Position(), Shader::Normal(), 
          Shader::TextureCoordinates(), Shader::Weight(), 3);




Le moteur propose un graphe de scène modulaire. Il repose sur un système templatisé vous permettant d'utiliser l'objet que vous souhaitez (matrices, quaternions, nombres complexes ou même vos propres implémentations de transformation). L'architecture n'est donc pas linéaire et permet une meilleure flexibilité.

Magnum supporte aussi les plugins afin d'importer vos fichiers de ressources facilement et cela, sans détruire la compatibilité de la bibliothèque avec des plateformes plus limitées. Vous pouvez déjà trouver des plugins dans un répertoire Git à part.
Même si la bibliothèque mathématique de Magnum est limitée, il est possible de créer des interfaces pour utiliser des types définis dans des bibliothèques externes.

La documentation fait partie intégrante de la bibliothèque et possède pour chaque classe, une introduction et un exemple d'utilisation. De plus, Magnum propose aussi des exemples complets.

N'hésitez pas à visiter la page des applications réalisées avec Magnum pour vous convaincre de l'essayer, d'autant plus que la licence utilisée est la licence MIT/Expat très permissive.

Vous pouvez télécharger la bibliothèque en suivant ce lien.

Votre opinion

Que pensez-vous de l'utilisation faite des fonctionnalités du C++11 dans la bibliothèque ?
Allez-vous essayer la bibliothèque ?
Préférez-vous utiliser une OpenGL directement, ou un wrapper ?

Source

Site officiel


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :
Offres d'emploi IT
Ingénieur base de données h/f
DE GRAËT CONSULTING - Pays de la Loire - Angers (49000)
Analyste développeur h/f
LITOO - Ile de France - Paris (75000)
Ingénieur Système unix
Atos Technology Services - Aquitaine - Bordeaux (33000)

Voir plus d'offres Voir la carte des offres IT
Responsable bénévole de la rubrique 2D - 3D - Jeux : LittleWhite -