Introduction

Ce moteur de rendu 3D est un projet complexe visant à créer des scènes tridimensionnelles informatiques.
Il combine plusieurs techniques de la programmation graphique, depuis le dessin de lignes et formes simples jusqu'à la simulation de l'illumination et de textures sur des objets 3D.

Chaque étape est expliquée pour rendre les concepts compréhensibles même pour ceux qui n'ont pas une expertise en graphisme informatique.

Contexte du Projet

Initialement conçu comme une série de travaux pratiques, ce projet est né dans le contexte académique du BUT Informatique Graphique au Puy en Velay, un cursus mettant l'accent sur la 3D.
L'objectif était d'acquérir une compréhension fondamentale de la programmation 3D, en abordant des concepts clés et des techniques essentielles, tout en renforçant notre maîtrise du langage Python.

Ambition du Projet

L'ambition de ce projet était double: d'une part, apprendre et comprendre les bases de la 3D sur ordinateur, et d'autre part, approfondir notre connaissance en Python.
À travers ce projet, nous avons exploré comment les objets 3D sont construits, manipulés et rendus, en acquérant une compréhension approfondie des processus impliqués.

Outils & Technologies Utilisés

Fondations: Tracé Algorithmique

La Base: Dessiner Lignes et Formes

Le projet commence par le fondamental de tout graphisme informatique: le tracé de lignes et de formes.
Des algorithmes spécifiques, tels que ceux de Bresenham et du point milieu, sont utilisés pour cette tâche. Ils permettent de déterminer quels pixels sur un écran doivent être allumés pour former une ligne ou une forme.
Imaginez dessiner un point à chaque pas jusqu'à former une ligne complète - c'est le principe de base de ces algorithmes.

# Exemple simplifié de tracé de ligne horizontale
class Horizontale(Courbe):     
    def ajouterControle(self, point):
        """ Ajoute un point de controle a l'horizontale.
        Ne fait rien si les 2 points existent deja. """
        if len(self.controles) < 2:
            Courbe.ajouterControle(self, point)
 
    def dessinerPoints(self, dessinerPoint):
        """ Dessine la courbe. Redefinit la methode de la classe mere. """
        if len(self.controles) == 2 :
            x1 = self.controles[0][0]
            x2 = self.controles[1][0]
            y = self.controles[0][1]
            xMin = min(x1,x2)
            xMax = max(x1, x2)
            for x in range(xMin, xMax):
                dessinerPoint((x, y),(0,0,0))

Architecture MVC pour l'Organisation

Le projet utilise l'architecture Modèle-Vue-Contrôleur (MVC).
Cette méthode divise l'application en trois parties interconnectées: le modèle gère les données et la logique, la vue s'occupe de l'affichage, et le contrôleur fait le lien entre le modèle et la vue.
Cette séparation facilite la gestion du projet et rend le code plus clair.

Évolution: Remplissage et Affichage en 3D

Du Simple au Complexe: Remplissage de Triangles

Après avoir maîtrisé le tracé de lignes, le projet évolue vers le remplissage de formes, en commençant par les triangles.
Le triangle est la forme de base en 3D en les combinant, on peut créer n'importe quelle surface.
Le remplissage de triangles est donc une étape cruciale pour construire des objets 3D.

# Exemple de la classe pour le remplissage de triangles
class TriangleRempli(Courbe):
    # ...

Visualisation en Fil de Fer

La visualisation en fil de fer est une technique où seules les arêtes des objets 3D sont dessinées, comme un maillage.
Elle est utile pour comprendre la structure d'un objet 3D sans être submergé par les détails.
Pour cela, l'algorithme du point milieu est utilisé, offrant une méthode efficace pour relier les points dans l'espace 3D.

# Extrait montrant la gestion des fichiers .sce et .obj
class Donnees_scene():
    # ...

Perfectionnement: Algorithme du Peintre et Gestion de la Profondeur

Passage au Réalisme: Algorithme du Peintre

L'algorithme du peintre est un pas vers un rendu plus réaliste.
Contrairement à la visualisation en fil de fer, il permet de remplir les surfaces des objets 3D, en utilisant des couleurs et des ombres pour donner une impression de profondeur et de réalité.

# Exemple d'utilisation de TriangleRempli avec l'algorithme du peintre
class TriangleRempli():
    # ...

Z-Buffer: Gérer Qui Est Devant Qui

Une problématique en 3D est de déterminer quel objet doit être affiché devant un autre. Le Z-Buffer est une solution à ce problème.
Il s'agit d'une grille où chaque case correspond à un pixel à l'écran et contient l'information de profondeur.
Ainsi, on peut savoir quel objet doit apparaître devant un autre.

# Exemple de la classe ZBuffer pour la gestion de la profondeur
class ZBuffer():
    def __init__(self) :
        self.zbuffer=[]
        self.dimx=0
        self.dimy=0
         
         
    def alloc_init_zbuffer(self,larg, haut):
        """initialisation du z-buffer"""
        self.zbuffer=[[] for i in range(larg)]
        self.dimx=larg
        self.dimy=haut
        for i in range(larg):
            col=haut*[100000]
            self.zbuffer[i]=col
            
    def acces(self,i,j):
        return self.zbuffer[i][j]
    
    def modif(self,i,j,val):
        self.zbuffer[i][j]=val

Avancées: Illumination et Texturation

Illumination avec Phong

Le modèle d'illumination de Phong est utilisé pour simuler comment la lumière interagit avec les surfaces des objets.
Il combine l'illumination ambiante (lumière globale), diffuse (réflexion mat) et spéculaire (reflets brillants) pour donner un aspect plus naturel et réaliste aux objets 3D.

# Calcul de la couleur selon Phong
def calculercouleur(self, M3D, scene):
    # ...

Texturation: Ajouter des Détails

La texturation consiste à appliquer des images 2D sur les surfaces des objets 3D pour ajouter des détails comme des motifs ou des couleurs.
Cela enrichit visuellement les objets sans alourdir le calcul nécessaire pour les créer.

# Application de textures sur les objets 3D
def interpoltriangle_avectexture(self, P1, P2, P3, T1, T2, T3, M3D):
    # ...

Compétences Développées

• 📐 Conception 3D
• 🐍 Programmation Python
• 🖥️ Rendu 3D
• 🧠 Résolution de problèmes
• 👁️ Perception spatiale
• 🔄 Adaptabilité

Conclusion

Ce projet de moteur de rendu 3D est un assemblage complexe de techniques graphiques, allant du tracé de lignes simples à la simulation d'illumination et de texturation sur des objets 3D.

En rétrospective, bien que le projet ait atteint ses objectifs initiaux, une exploration plus poussée de l'optimisation des performances et de l'intégration de fonctionnalités interactives aurait pu enrichir davantage l'expérience utilisateur.
Ce travail a été un formidable terrain d'apprentissage, mettant en évidence l'importance de l'organisation du code et de la gestion efficace des ressources en Programmation graphique.

Le projet est accessible sur GitHub et je vous invite à le consulter pour une expérience plus complète.