Travailler en 3D avec Pygame

1. PyOpenGL

Il existe un module Python qui permet de travailler avec OpenGL. Il s’agit de PyOpenGL. S’il n’est pas installé sur votre machine, cette commande pip lancée dans le terminal vous permet de le faire.

pip install PyOpenGL 

Pour l’utiliser dans un code Python, il suffit d’importer le module comme il est fait habituellement (pour Pygame, par exemple). En général, nous procédons à l’import en écrivant ces deux lignes :

from OpenGL.GL import * 
from OpenGL.GLU import * 

2. Les notions fondamentales : sommet et arête

Pour définir les objets 3D dans OpenGL, nous allons utiliser deux notions fondamentales : celle de sommet (vertex en anglais) et celle d’arête (edge en anglais).

De façon schématique, nous pouvons considérer que les sommets sont des points de l’espace et donc ont leurs coordonnées en trois dimensions. Par exemple : (1, 2, -4). Les arêtes sont les segments qui relient les sommets.

Ainsi, si nous définissons deux sommets :

Cela revient à considérer que définir les objets 3D dans OpenGL, c’est avant tout définir une collection de points tridimensionnels (les sommets) et de définir ensuite les arêtes qui relient entre eux ces sommets.

3. PyOpenGL et Pygame

Quand nous créons la fenêtre de jeu Pygame, nous spécifions un mode de fonctionnement relatif à OpenGL. La valeur utilisée est : pygame.DOUBLEBUF|pygame.OPENGL.

Nous avons par exemple ce type de code :

import pygame 
pygame.init() 
ZONE = (800,800) 
pygame.display.set_mode(ZONE...

1. Le code global

Commençons par présenter le code global de l’exemple, avant de procéder à l’explication détaillée du programme.

import pygame  
from OpenGL.GL import *  
from OpenGL.GLU import *  
  
SOMMETS = (  
   (1, -1, -1),  
   (1, 1, -1),  
   (-1, 1, -1),  
   (-1, -1, -1),  
   (1, -1, 1),  
   (1, 1, 1),  
   (-1, -1, 1),  
   (-1, 1, 1)  
   ) 
 
ARETES = ( 
   (0,1), 
   (0,3), 
   (0,4), 
   (2,1), 
   (2,3), 
   (2,7), 
   (6,3), 
   (6,4), 
   (6,7), 
   (5,1), 
   (5,4), 
   (5,7) 
   ) 
 
 
def Cube(): 
   glBegin(GL_LINES) 
   for arete in ARETES: 
       for sommet in arete: 
           glVertex3fv(SOMMETS[sommet]) 
   glEnd() 
 
pygame.init() 
ZONE = (800,800) 
pygame.display.set_mode(ZONE, pygame.DOUBLEBUF|pygame.OPENGL) 
 
gluPerspective(45, (ZONE[0]/ZONE[1]), 0.1, 50.0) 
glTranslatef(0.0,0.0, -5) 
 
while True:  
 for event in pygame.event.get(): 
   if event.type == pygame.QUIT: 
     pygame.quit() 
     quit() ...

1. Le code global

Nous retrouvons largement la trame du code global précédent à laquelle nous avons ajouté la gestion des surfaces et des couleurs.

import pygame 
from OpenGL.GL import * 
from OpenGL.GLU import * 
  
COULEURS = ( 
 (1,0,0), 
 (0,1,0), 
 (0,0,1), 
 (1,0,0), 
 (0,1,0), 
 (0,0,1), 
 (1,0,0), 
 (0,1,0),  
 (0,0,1), 
 (1,0,0), 
 (0,1,0), 
 (0,0,1), 
) 
 
SOMMETS = ( 
 (1, -1, -1), 
 (1, 1, -1), 
 (-1, 1, -1), 
 (-1, -1, -1), 
 (1, -1, 1), 
 (1, 1, 1), 
 (-1, -1, 1), 
 (-1, 1, 1) 
) 
 
ARETES = ( 
 (0,1), 
 (0,3), 
 (0,4), 
 (2,1), 
 (2,3), 
 (2,7), 
 (6,3), 
 (6,4), 
 (6,7), 
 (5,1), 
 (5,4), 
 (5,7) 
) 
 
SURFACES = ( 
 (0,1,2,3), 
 (3,2,7,6), 
 (6,7,5,4), 
 (4,5,1,0), 
 (1,5,7,2), 
 (4,0,3,6) 
) 
 
def Cube(): 
 glBegin(GL_QUADS) 
 for surface in SURFACES: 
   cmp = 0 
   for vertex in surface: 
     cmp+=1 
 ...

1. Définition

Un moteur de jeu vidéo est un ensemble logiciel qui permet de se faciliter la vie dans le cadre d’un développement de jeu vidéo. Prenons comme exemple le développement d’un jeu qui consiste à lancer un ballon sur le sol, ballon qui rebondit de façon réaliste, parfois sur le sol, parfois dans une flaque d’eau, auquel cas la simulation diffère un peu (projection d’eau, amortissement, etc.). Le moteur permet de se préoccuper de l’essentiel du jeu de simulation, c’est-à-dire le décor, la jouabilité, le scénario. Les aspects techniques sont dévolus entièrement au moteur de jeu. Entre autres :

Autant d’aspects que nous pouvons regrouper dans une grande famille des aspects physiques, de représentations 2D/3D, de gestion des collisions, etc.

2. Créer son propre moteur de jeu ?

Pygame propose un certain nombre d’outils pour la gestion des collisions (fonctions de type spritecollide, etc.). Est-ce à dire que Pygame est un moteur de jeu ? Absolument pas. Certes, des aspects de Pygame pourraient le laisser penser (gestion des collisions, donc), mais cela ne va pas beaucoup plus loin. C’est tout simplement que ce n’est pas le rôle de Pygame, qui reste relativement bas niveau. Nous avons pu voir que faire de la 3D directement avec OpenGL n’est pas chose aisée, d’où l’intérêt d’avoir une surcouche qui encapsule des tâches récurrentes.

Dans le contexte Pygame, un moteur de jeu est donc plutôt une couche logicielle qui serait « au-dessus » de Pygame et qui encapsulerait un certain...