PyOpenGl ou pyglet?

commencez avec pyglet. Il contient la meilleure API de haut niveau, qui contient tout ce dont vous avez besoin pour démarrer, de l'ouverture d'une fenêtre au dessin des Sprites et des primitives OpenGL en utilisant leurs classes sprite et Batch conviviales et puissantes.

plus tard, vous voudrez peut-être aussi écrire votre propre code de niveau inférieur, qui fait des appels directement vers des fonctions OpenGL telles que glDrawArrays, etc. Vous pouvez le faire en utilisant les fixations OpenGL de pyglet, ou en utilisant PyOpenGL. La bonne nouvelle est que peu importe ce que vous utilisez, vous peut insérer de tels appels directement au milieu de votre application pyglet existante, et ils "ne feront que fonctionner". La transition de votre code de Pyglet à PyOpenGL est assez facile, donc ce n'est pas une décision que vous devez vous soucier de trop d'avance. Les métiers de la compensation entre les deux sont les suivantes:

les fixations de PyOpenGL rendent L'interface OpenGL plus conviviale et pythonique. Par exemple, vous pouvez passer des tableaux de vertex dans de nombreuses formes différentes, des tableaux ctypes, des tableaux numpy, des listes simples, etc, et PyOpenGL sera les transformer en quelque chose Qu'OpenGL peut utiliser. Ce genre de choses rend PyOpenGL vraiment facile et pratique.

les fixations OpenGL de pyglet sont générées automatiquement et ne sont pas aussi conviviales à utiliser que PyOpenGL. Par exemple, parfois vous devrez créer manuellement des objets ctypes, afin de passer des args 'c pointer' à OpenGL. Cela peut être laborieux. Le côté positif, cependant, c'est que les fixations de pyglet ont tendance à être beaucoup plus rapides.

Cela implique qu'il y est un optimal terrain du milieu: utilisez pyglet pour le fenêtrage, les événements de souris, le son, etc. Ensuite, utilisez L'API conviviale de PyOpenGL lorsque vous voulez faire des appels directs à la fonction OpenGL. Ensuite, lors de l'optimisation, remplacez seulement le faible pourcentage d'appels PyOpenGL critiques pour les performances qui se trouvent dans votre boucle de rendu interne par les équivalents pyglet. Pour moi, cela me donne entre 2 et 4 fois plus de cadrerates, avec la commodité de PyOpenGL pour 90% de mon code.

je dirais que Pyglet est en fait plus évolué que PyOpenGL. Il dispose d'une bonne API, et Il dispose d'une enveloppe complète autour D'OpenGL accessible via le pyglet.module gl! PyOpenGL n'enveloppe même pas toutes les fonctions D'OpenGL. Pyglet dispose également d'une excellente bibliothèque pour le rendu 2D avec l'accélération matérielle par OpenGL, et c'est vraiment bien fait.

si vous voulez un puissant moteur 3D prêt à l'emploi vous avez Ogre et ces

ModernGL.

pip install ModernGL

• PyOpenGL est une version générée automatiquement de L'API OpenGL originale (générée avec SWIG). L'API OpenGL originale N'est pas conviviale pour python. Les fixations python générées sont difficiles à utiliser.

• pyglet est principalement pour la création de fenêtres et la gestion d'événements, mais vous pouvez utiliser une API PyOpenGL comme par exemple pyglet.gl.glClearColor)

• pygame fournit une fenêtre où vous pouvez utiliser PyOpenGL pour faire le rendu.

• ModernGL est une excellente alternative à PyOpenGL, vous pouvez utiliser L'API OpenGL moderne avec moins de code écrit. ModernGL ne crée pas une fenêtre par elle-même, mais vous pouvez l'intégrer dans pyglet, pygame,PyQt5 et même GLUT.

dans ModernGL vous pouvez créer un programme de shader simple avec un seul appel:

prog = ctx.program(
    vertex_shader='''
        #version 330
        in vec2 in_vert;
        void main() {
            gl_Position = vec4(in_vert, 0.0, 1.0);
        }
    ''',
    fragment_shader='''
        #version 330
        out vec4 f_color;
        void main() {
            f_color = vec4(0.3, 0.5, 1.0, 1.0);
        }
    ''',
)

avec ModernGL vous avez le contrôle total sur L'API OpenGL.

pyglet a beaucoup d'extras inclus avec (comme le chargement d'image et le son). Si tu commences, je vais d'abord essayer pyglet, puis passer à PyOpenGL si tu as envie de te rapprocher du métal.

La vraie question importante est: qu'essayez-vous de réaliser?

je fais la promotion de pyglet parce qu'il a la plus belle API que j'ai jamais vu sur des trucs comme ça.

Pyglet possède aussi l'API opengl. Mais il est souvent plus agréable d'utiliser la liste vertex récemment ajoutée.

pyglet.gl

Hmm, je suggérerais pyglet, il fournit vraiment tout ce dont on a besoin pour un jeu ou une application.

rappelez-vous, vous pouvez faire beaucoup de choses pyglet avec PyOpenGL, par exemple pour créer une fenêtre tout ce que vous devez faire c'est:

glutInitWindow (title)

bien que je pense que glutInitDisplayMode doit être appelé avant cela.

résumé Simple: si vous ne voulez pas coder jusqu'à ce que vous pleuriez, choisissez pyglet, mais si vous voulez être un maître, choisissez PyOpenGL. Goto http://pyopengl.sourcefourge.net à lire les docs sur PyOpenGL et http://pyglet.org à lire les docs sur pyglet. Espérons que cela a été utile!

je recommande Pyglet parce qu'il est très facile de commencer et d'avoir quelque chose de Basique en cours d'exécution, et ensuite vous pouvez ajouter des techniques plus avancées à votre propre rythme.

l'API GL de pyglet est loin d'être aussi agréable que celle de PyOpenGL - pyglet à la couche brute de ctypes, ce qui veut dire que vous aurez besoin d'apprendre les ctypes aussi. Si vous prévoyez de faire un tas de programmation OpenGL, vous voudrez utiliser PyOpenGL.

La bonne chose est que vous pouvez mélanger les deux très bien. Utilisez pyglet pour fournir le contexte GL, les sons, les événements, le chargement d'image et la gestion de texture, le rendu de texte, etc, etc. Utilisez PyOpenGL pour la programmation actuelle D'OpenGL que vous devez faire.