Discussion :

[LittleWhite]

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 - Visualiser dans une fenêtre à part

    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 - Visualiser dans une fenêtre à part

    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 - Visualiser dans une fenêtre à part

    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 - Visualiser dans une fenêtre à part

    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 - Visualiser dans une fenêtre à part

    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 - Visualiser dans une fenêtre à part

    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