93 lines
2.9 KiB
Markdown
93 lines
2.9 KiB
Markdown
# 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)
|
|
```
|