# mainPainter.py
La classe qui gére l'affichage (de la partie principale, pas les ui d'infos)

## Imports
Comme d'hab les imports de Qt

```python
from PySide6.QtOpenGLWidgets import QOpenGLWidget
from PySide6.QtCore import Qt, QThread
from PySide6.QtGui import QPainter, QFont, QColor, QTransform, QOpenGLContext, QOpenGLFunctions
from PySide6 import QtOpenGL
```

## mainPainter
La classe principale, c'est un sous-classe de QOpenGLWidget

```python
class mainPainter(QOpenGLWidget):
```

## \_\_init\_\_
Notre initialisation, on récupère les deux classe de la carte et des voitures parce que c'est eux qui sont responsables de leurs affichage.
Le QTransform sert à calculer/stocker la transformation pour passer de coordonnées dans le monde réél-\>coords sur l'écran

```python
    def __init__(self, parent=None):
        super(mainPainter, self).__init__(parent)
         
        self.map = None
        self.carController = None
        self.transform = QTransform()
```

## addMap
Juste un fonction pour passer la carte, on pourrait probablement le faire passer dans le constructeur plutôt

```python
    def addMap(self, netMap):
        self.map = netMap
```

## addCarController
Comme [addMap](#addMap)

```python
    def addCarController(self, cc):
        self.carController = cc
```

## generateTransform
La fonction qui genere la transformation monde-\>écran.
On récupere les limites du réseau, puis on translate/scale en fonction
Pour avoir un peu de marge on rajoute 10 de tout les côtés
Comme l'origine est en haut à gauche et les y decroissant on scale de -1 sur y pour remettre l'image à l'endroit

```python
    def generateTransform(self):
        bounds = self.map.getBounds()
        if(bounds is None):
            return
        bounds[0] = list(map(lambda b: b-10,bounds[0]))
        bounds[1] = list(map(lambda b: b+10, bounds[1]))
        self.transform.reset()
        tr = QTransform()
        tr.translate(-bounds[0][0],-bounds[0][1])
        scale=min(self.width()/(bounds[1][0]-bounds[0][0]),self.height()/(bounds[1][1]-bounds[0][1]))
        sc = QTransform()
        sc.scale(scale,-scale)
        self.transform = tr * sc * QTransform(1, 0, 0, 1, 0, self.height())
```

## resizeGL
Fonction appelé quand le widget est redimensionné (ça inclut la création), le cas échéant on recalcule la transformation avec la nouvelle taille

```python
    def resizeGL(self,w,h):
        self.generateTransform()
```

## paintEvent
Fonction appelé à chaque appel sur update.
On crée notre QPainter, on active l'anti-aliasing (marche pas en openGL apparement), on clear l'écran, on applique la transformation et on demande à notre carte et nos voitures de se dessiner.

```python
    def paintEvent(self, e):
        painter = QPainter(self)
        painter.RenderHint(QPainter.Antialiasing)
        painter.eraseRect(e.rect());
        painter.setTransform(self.transform)
        self.map.draw(painter)
        self.carController.draw(painter)
```
