843 lines
28 KiB
C
843 lines
28 KiB
C
#include "controleAffichage.h"
|
|
|
|
|
|
Point** affichageLogs(sfRenderWindow *const window, sfRenderTexture *renderTexture, Point *tabPoint, uint32_t nbElements, uint32_t *nbPointsAffiches, uint32_t nbPointAgglosMin, sfCircleShape *tabPointeursCercle[nbElements], Agglomerat *agglos, uint32_t nbAgglos, Route *route, uint32_t nbRoutes, sfVertexArray *tabPointeursArray[nbRoutes], sfCircleShape *tabPointeursCercleAgglos[nbAgglos], uint32_t *const nbAgglosAffiches, bool allPoint, bool allRoads, const Carte *const carte, const Mode mode, Menu *const menu)
|
|
{
|
|
switch(mode)
|
|
{
|
|
case MODE_GLOBAL:
|
|
return affichageLogsGlobal(window, renderTexture, tabPoint, nbElements, nbPointsAffiches, nbPointAgglosMin, tabPointeursCercle, agglos, nbAgglos, route, nbRoutes, tabPointeursArray, tabPointeursCercleAgglos, allPoint, allRoads, carte);
|
|
|
|
case MODE_PREVIEW:
|
|
return affichageLogsPreview(window, renderTexture, tabPoint, nbElements, nbPointsAffiches, nbPointAgglosMin, tabPointeursCercle, agglos, nbAgglos, route, nbRoutes, tabPointeursArray, tabPointeursCercleAgglos, allPoint, allRoads, carte);
|
|
|
|
case MODE_PREVIEW_SUGG:
|
|
return affichageLogsPreviewSugg(window, renderTexture, tabPoint, nbElements, nbPointsAffiches, nbPointAgglosMin, tabPointeursCercle, agglos, nbAgglos, route, nbRoutes, tabPointeursArray, tabPointeursCercleAgglos, allPoint, allRoads, carte);
|
|
|
|
case MODE_PBP_AUTOMATIC:
|
|
return affichageLogsPBPAuto(window, renderTexture, tabPoint, nbElements, nbPointsAffiches, nbPointAgglosMin, tabPointeursCercle, agglos, nbAgglos, tabPointeursCercleAgglos, nbAgglosAffiches, carte, menu);
|
|
|
|
case MODE_PBP_MANUAL:
|
|
return affichageLogsPBPManual(window, renderTexture, tabPoint, nbElements, nbPointsAffiches, nbPointAgglosMin, tabPointeursCercle, agglos, nbAgglos, tabPointeursCercleAgglos, nbAgglosAffiches, carte, menu);
|
|
|
|
default:
|
|
;
|
|
sfSprite *renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
warningBox(window, renderSprite, "Mode non géré.\n");
|
|
freeSprite(&renderSprite);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
Point** affichageLogsGlobal(sfRenderWindow *const window, sfRenderTexture *renderTexture, Point *tabPoint, uint32_t nbElements, uint32_t *nbPointsAffiches, uint32_t nbPointAgglosMin, sfCircleShape *tabPointeursCercle[nbElements], Agglomerat *agglos, uint32_t nbAgglos, Route *route, uint32_t nbRoutes, sfVertexArray *tabPointeursArray[nbRoutes], sfCircleShape *tabPointeursCercleAgglos[nbAgglos], bool allPoint, bool allRoads, const Carte *const carte)
|
|
{
|
|
uint32_t nbPtsNonAffiches = 0;
|
|
*nbPointsAffiches = 0;
|
|
sfVertexArray * ligneRoute = NULL;
|
|
|
|
Point** tmpPtsAffiches = calloc(nbElements, sizeof(Point*));
|
|
if(tmpPtsAffiches == NULL)
|
|
{
|
|
sfSprite *renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
warningBox(window, renderSprite, strerror(errno));
|
|
freeSprite(&renderSprite);
|
|
return NULL;
|
|
}
|
|
|
|
for(uint32_t i=0;i < nbElements;i++)
|
|
{
|
|
// Si le point n'est pas sur la carte (avec l'échelle actuelle), on passe directement au suivant #optimisationMaGueule
|
|
// En mode MODE_GLOBAL, on n'affiche pas les points formant un agglomérats (sauf en mode allPoint), la fin du corps de la fonction s'en chargera...
|
|
if((!pointOnMap(&tabPoint[i].posConv)) || (tabPoint[i].type == AGGLOMERAT && !allPoint))
|
|
{
|
|
nbPtsNonAffiches++;
|
|
continue;
|
|
}
|
|
|
|
else
|
|
{
|
|
if(tabPoint[i].aSupprimer)
|
|
{
|
|
dessinerPoint(renderTexture, tabPoint[i].posConv, &tabPointeursCercle[(*nbPointsAffiches)++], COULEUR_POINT_SUPPRIME);
|
|
}
|
|
else
|
|
{
|
|
Route* r = (Route*)tabPoint[i].ptOnStructure;
|
|
if(!(tabPoint[i].type == AGGLOMERAT))
|
|
{
|
|
if((r->ptAgglo[0] != NULL && r->ptAgglo[0]->aSupprimer) || (r->ptAgglo[1] != NULL && r->ptAgglo[1]->aSupprimer))
|
|
{
|
|
dessinerPoint(renderTexture, tabPoint[i].posConv, &tabPointeursCercle[(*nbPointsAffiches)++], COULEUR_POINT_SUGGERE);
|
|
}
|
|
else
|
|
{
|
|
dessinerPoint(renderTexture, tabPoint[i].posConv, &tabPointeursCercle[(*nbPointsAffiches)++], COULEUR_POINT);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dessinerPoint(renderTexture, tabPoint[i].posConv, &tabPointeursCercle[(*nbPointsAffiches)++], COULEUR_POINT);
|
|
}
|
|
}
|
|
tmpPtsAffiches[i - nbPtsNonAffiches] = tabPoint + i;
|
|
}
|
|
}
|
|
if(!allPoint)
|
|
{
|
|
for(uint32_t i = 0; i < nbAgglos; i++)
|
|
{
|
|
if(!agglos[i].aSupprimer)
|
|
dessinerAgglo(renderTexture, &agglos[i], &tabPointeursCercleAgglos[i], nbPointAgglosMin, carte, COULEUR_AGGLO);
|
|
else
|
|
dessinerAgglo(renderTexture, &agglos[i], &tabPointeursCercleAgglos[i], nbPointAgglosMin, carte, COULEUR_AGGLO_SUPPRIME);
|
|
}
|
|
}
|
|
|
|
if(allRoads)
|
|
{
|
|
for(uint32_t i=0; i<nbRoutes; i++)
|
|
{
|
|
ligneRoute = creerDroiteFromRoute(route[i], i, MODE_GLOBAL);
|
|
tabPointeursArray[i] = ligneRoute;
|
|
sfRenderTexture_drawVertexArray(renderTexture, ligneRoute, NULL);
|
|
}
|
|
}
|
|
|
|
sfRenderTexture_display(renderTexture);
|
|
|
|
sfSprite * renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
|
|
Point **ptsAffiches = copieTabPointeurPt(tmpPtsAffiches, *nbPointsAffiches);
|
|
free(tmpPtsAffiches);
|
|
freeSprite(&renderSprite);
|
|
return ptsAffiches;
|
|
}
|
|
|
|
|
|
Point** affichageLogsPreview(sfRenderWindow *const window, sfRenderTexture *renderTexture, Point *tabPoint, uint32_t nbElements, uint32_t *nbPointsAffiches, uint32_t nbPointAgglosMin, sfCircleShape *tabPointeursCercle[nbElements], Agglomerat *agglos, uint32_t nbAgglos, Route *route, uint32_t nbRoutes, sfVertexArray *tabPointeursArray[nbRoutes], sfCircleShape *tabPointeursCercleAgglos[nbAgglos], bool allPoint, bool allRoads, const Carte *const carte)
|
|
{
|
|
uint32_t nbPtsNonAffiches = 0;
|
|
*nbPointsAffiches = 0;
|
|
sfVertexArray * ligneRoute = NULL;
|
|
|
|
Point** tmpPtsAffiches = calloc(nbElements, sizeof(Point*));
|
|
if(tmpPtsAffiches == NULL)
|
|
{
|
|
sfSprite *renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
warningBox(window, renderSprite, strerror(errno));
|
|
freeSprite(&renderSprite);
|
|
return NULL;
|
|
}
|
|
for(uint32_t i=0;i < nbElements;i++)
|
|
{
|
|
// Si le point n'est pas sur la carte (avec l'échelle actuelle), on passe directement au suivant #optimisationMaGueule
|
|
// En mode MODE_PREVIEW, on n'affiche pas les points sélectionnés pour être supprimé
|
|
// En mode MODE_PREVIEW, on n'affiche pas les points formant un agglomérats (sauf en mode allPoint), la fin du corps de la fonction s'en chargera...
|
|
if(!pointOnMap(&tabPoint[i].posConv) || tabPoint[i].aSupprimer || tabPoint[i].type == AGGLOMERAT)
|
|
{
|
|
nbPtsNonAffiches++;
|
|
continue;
|
|
}
|
|
|
|
else
|
|
{
|
|
Route* r = (Route*)tabPoint[i].ptOnStructure;
|
|
if(((r->ptAgglo[0] != NULL && r->ptAgglo[0]->aSupprimer) || (r->ptAgglo[1] != NULL && r->ptAgglo[1]->aSupprimer)))
|
|
{
|
|
dessinerPoint(renderTexture, tabPoint[i].posConv, &tabPointeursCercle[(*nbPointsAffiches)++], COULEUR_POINT_SUGGERE);
|
|
}
|
|
else
|
|
{
|
|
dessinerPoint(renderTexture, tabPoint[i].posConv, &tabPointeursCercle[(*nbPointsAffiches)++], COULEUR_POINT);
|
|
}
|
|
tmpPtsAffiches[i - nbPtsNonAffiches] = tabPoint + i;
|
|
}
|
|
}
|
|
if(!allPoint)
|
|
{
|
|
for(uint32_t i = 0; i < nbAgglos; i++)
|
|
{
|
|
if(!agglos[i].aSupprimer)
|
|
dessinerAgglo(renderTexture, &agglos[i], &tabPointeursCercleAgglos[i], nbPointAgglosMin, carte, COULEUR_AGGLO);
|
|
}
|
|
}
|
|
|
|
if(allRoads)
|
|
{
|
|
for(uint32_t i=0; i<nbRoutes; i++)
|
|
{
|
|
ligneRoute = creerDroiteFromRoute(route[i], i, MODE_PREVIEW);
|
|
tabPointeursArray[i] = ligneRoute;
|
|
sfRenderTexture_drawVertexArray(renderTexture, ligneRoute, NULL);
|
|
}
|
|
}
|
|
|
|
sfRenderTexture_display(renderTexture);
|
|
|
|
sfSprite * renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
|
|
Point **ptsAffiches = copieTabPointeurPt(tmpPtsAffiches, *nbPointsAffiches);
|
|
free(tmpPtsAffiches);
|
|
freeSprite(&renderSprite);
|
|
return ptsAffiches;
|
|
}
|
|
|
|
|
|
Point** affichageLogsPreviewSugg(sfRenderWindow *const window, sfRenderTexture *renderTexture, Point *tabPoint, uint32_t nbElements, uint32_t *nbPointsAffiches, uint32_t nbPointAgglosMin, sfCircleShape *tabPointeursCercle[nbElements], Agglomerat *agglos, uint32_t nbAgglos, Route *route, uint32_t nbRoutes, sfVertexArray *tabPointeursArray[nbRoutes], sfCircleShape *tabPointeursCercleAgglos[nbAgglos], bool allPoint, bool allRoads, const Carte *const carte)
|
|
{
|
|
uint32_t nbPtsNonAffiches = 0;
|
|
*nbPointsAffiches = 0;
|
|
sfVertexArray * ligneRoute = NULL;
|
|
|
|
Point** tmpPtsAffiches = calloc(nbElements, sizeof(Point*));
|
|
if(tmpPtsAffiches == NULL)
|
|
{
|
|
sfSprite *renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
warningBox(window, renderSprite, strerror(errno));
|
|
freeSprite(&renderSprite);
|
|
return NULL;
|
|
}
|
|
|
|
for(uint32_t i=0;i < nbElements;i++)
|
|
{
|
|
// Si le point n'est pas sur la carte (avec l'échelle actuelle), on passe directement au suivant #optimisationMaGueule
|
|
// En mode MODE_PREVIEW, on n'affiche pas les points sélectionnés pour être supprimé
|
|
// En mode MODE_PREVIEW, on n'affiche pas les points formant un agglomérats (sauf en mode allPoint), la fin du corps de la fonction s'en chargera...
|
|
if(!pointOnMap(&tabPoint[i].posConv) || tabPoint[i].aSupprimer || tabPoint[i].type == AGGLOMERAT)
|
|
{
|
|
nbPtsNonAffiches++;
|
|
continue;
|
|
}
|
|
|
|
else
|
|
{
|
|
Route* r = (Route*)tabPoint[i].ptOnStructure;
|
|
if(!(!(tabPoint[i].type == AGGLOMERAT) &&
|
|
((r->ptAgglo[0] != NULL && r->ptAgglo[0]->aSupprimer) || (r->ptAgglo[1] != NULL && r->ptAgglo[1]->aSupprimer))))
|
|
{
|
|
dessinerPoint(renderTexture, tabPoint[i].posConv, &tabPointeursCercle[(*nbPointsAffiches)++], COULEUR_POINT);
|
|
tmpPtsAffiches[i - nbPtsNonAffiches] = tabPoint + i;
|
|
}
|
|
else
|
|
{
|
|
nbPtsNonAffiches++;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
if(!allPoint)
|
|
{
|
|
for(uint32_t i = 0; i < nbAgglos; i++)
|
|
{
|
|
if(!agglos[i].aSupprimer)
|
|
dessinerAgglo(renderTexture, &agglos[i], &tabPointeursCercleAgglos[i], nbPointAgglosMin, carte, COULEUR_AGGLO);
|
|
}
|
|
}
|
|
|
|
if(allRoads)
|
|
{
|
|
for(uint32_t i=0; i<nbRoutes; i++)
|
|
{
|
|
ligneRoute = creerDroiteFromRoute(route[i], i, MODE_PREVIEW_SUGG);
|
|
tabPointeursArray[i] = ligneRoute;
|
|
sfRenderTexture_drawVertexArray(renderTexture, ligneRoute, NULL);
|
|
}
|
|
}
|
|
|
|
sfRenderTexture_display(renderTexture);
|
|
|
|
sfSprite * renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
|
|
Point **ptsAffiches = copieTabPointeurPt(tmpPtsAffiches, *nbPointsAffiches);
|
|
free(tmpPtsAffiches);
|
|
freeSprite(&renderSprite);
|
|
return ptsAffiches;
|
|
}
|
|
|
|
|
|
Point** affichageLogsPBPAuto(sfRenderWindow *const window, sfRenderTexture *renderTexture, Point *tabPoint, uint32_t nbElements, uint32_t *nbPointsAffiches, uint32_t nbPointAgglosMin, sfCircleShape *tabPointeursCercle[nbElements], Agglomerat *agglos, uint32_t nbAgglos, sfCircleShape *tabPointeursCercleAgglos[nbAgglos], uint32_t *const nbAgglosAffiches, const Carte *const carte, Menu *const menu)
|
|
{
|
|
sfEvent event;
|
|
uint32_t nbPtsNonAffiches = 0;
|
|
*nbPointsAffiches = 0;
|
|
*nbAgglosAffiches = 0;
|
|
|
|
uint32_t numAgglo = 0;
|
|
|
|
sfSprite *renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
|
|
bool postAgglo = false;
|
|
|
|
Point** tmpPtsAffiches = calloc(nbElements, sizeof(Point*));
|
|
if(tmpPtsAffiches == NULL)
|
|
{
|
|
warningBox(window, renderSprite, strerror(errno));
|
|
freeSprite(&renderSprite);
|
|
return NULL;
|
|
}
|
|
|
|
// Booléens de gestion du menu !
|
|
bool cancelDisplay = false;
|
|
|
|
// Booléens d'optimisations graphiques !
|
|
bool displayPaused = true;
|
|
|
|
// Bouton que l'on affiche
|
|
Bouton *boutonActuel = NULL;
|
|
|
|
// Une texture NON-MODIFIÉE qui fera juste office de "roll-back" si l'utilisateur répète l'afichage !
|
|
sfTexture *firstTexture = sfTexture_copy(sfRenderTexture_getTexture(renderTexture));
|
|
|
|
// Une texture pour copier celle de rendus pour la gestion des descriptions
|
|
// Copie de l'actuelle ici pour qu'elle soit dans tous les cas non-nulle dans le futur
|
|
sfTexture *originalTexture = sfTexture_copy(sfRenderTexture_getTexture(renderTexture));;
|
|
|
|
for(uint32_t i = 0; i < nbElements; i++)
|
|
{
|
|
sfRenderTexture_display(renderTexture);
|
|
freeSprite(&renderSprite);
|
|
renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
|
|
// À chaque point supplémentaire, on effectue une petite pause pour avoir un affichage "homogène" sur toutes les plateformes d'exécution...
|
|
sfSleep((sfTime){DELAYPOINTBYPOINT});
|
|
|
|
do
|
|
{
|
|
while(sfRenderWindow_pollEvent(window, &event))
|
|
{
|
|
if(event.type == sfEvtClosed)
|
|
{
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
else if(event.type == sfEvtResized)
|
|
{
|
|
displayBackgroundSprite(window, renderSprite);
|
|
}
|
|
|
|
else if(event.type == sfEvtMouseMoved && displayPaused)
|
|
{
|
|
// Suppression de la description si une est affichée (et que l'on n'est plus dessus)
|
|
if(boutonActuel != NULL)
|
|
{
|
|
if(!mouseIsInRect((sfVector2f){event.mouseMove.x, event.mouseMove.y}, boutonActuel->zone))
|
|
{
|
|
boutonActuel = NULL;
|
|
resetTextureAndSpriteFromOriginal(renderTexture, &renderSprite, originalTexture);
|
|
freeSprite(&renderSprite);
|
|
renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
}
|
|
}
|
|
|
|
// Aucun bouton n'est affiché, on check la position du curseur !
|
|
else
|
|
{
|
|
if(event.mouseMove.x >= WIDTH)
|
|
{
|
|
// L'utilisateur est sur la zone du menu, l'affichage est en pause, aucun bouton n'est affiché --> stockons la texture !
|
|
sfTexture_destroy(originalTexture);
|
|
originalTexture = sfTexture_copy(sfRenderTexture_getTexture(renderTexture));
|
|
|
|
boutonActuel = afficherDescriptionBouton(&event, menu, renderTexture, &renderSprite);
|
|
if(boutonActuel != NULL)
|
|
{
|
|
freeSprite(&renderSprite);
|
|
renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
else if(event.type == sfEvtMouseButtonPressed && event.mouseButton.x >= WIDTH)
|
|
{
|
|
switch(whichTool(&event, menu))
|
|
{
|
|
case TOOL_EXIT:
|
|
exit(EXIT_SUCCESS);
|
|
|
|
case TOOL_BACKTOHOME:
|
|
free(tmpPtsAffiches);
|
|
return NULL;
|
|
|
|
case TOOL_GLOBAL:
|
|
cancelDisplay = true;
|
|
break;
|
|
|
|
case TOOL_ERASE:
|
|
displayPaused = true;
|
|
detruireCercles(*nbPointsAffiches, tabPointeursCercle);
|
|
*nbPointsAffiches = 0;
|
|
|
|
detruireCercles(*nbAgglosAffiches, tabPointeursCercleAgglos);
|
|
*nbAgglosAffiches = 0;
|
|
|
|
nbPtsNonAffiches = i;
|
|
|
|
postAgglo = false;
|
|
|
|
free(tmpPtsAffiches);
|
|
tmpPtsAffiches = calloc(nbElements, sizeof(Point*));
|
|
|
|
resetTextureAndSpriteFromOriginal(renderTexture, &renderSprite, firstTexture);
|
|
updateAndDrawMenu(renderTexture, menu, MODE_PBP_AUTOMATIC, false, displayPaused, NO_TOOL);
|
|
sfRenderTexture_display(renderTexture);
|
|
sfTexture_destroy(originalTexture);
|
|
originalTexture = sfTexture_copy(sfRenderTexture_getTexture(renderTexture));
|
|
displayBackgroundSprite(window, renderSprite);
|
|
break;
|
|
|
|
case TOOL_RESUME:
|
|
displayPaused = false;
|
|
resetTextureAndSpriteFromOriginal(renderTexture, &renderSprite, originalTexture);
|
|
updateAndDrawMenu(renderTexture, menu, MODE_PBP_AUTOMATIC, false, displayPaused, NO_TOOL);
|
|
sfRenderTexture_display(renderTexture);
|
|
freeSprite(&renderSprite);
|
|
renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
sfTexture_destroy(originalTexture);
|
|
originalTexture = sfTexture_copy(sfRenderTexture_getTexture(renderTexture));
|
|
break;
|
|
|
|
case TOOL_PAUSE:
|
|
displayPaused = true;
|
|
updateAndDrawMenu(renderTexture, menu, MODE_PBP_AUTOMATIC, false, displayPaused, NO_TOOL);
|
|
// L'affichage est en pause, avant que l'utilisateur puisse afficher les descriptions, on stocke la texture actuelle !
|
|
sfTexture_destroy(originalTexture);
|
|
originalTexture = sfTexture_copy(sfRenderTexture_getTexture(renderTexture));
|
|
sfRenderTexture_display(renderTexture);
|
|
freeSprite(&renderSprite);
|
|
renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
break;
|
|
|
|
case TOOL_REPEAT:
|
|
// À la prochaine itération l'affichage sera en pause
|
|
displayPaused = true;
|
|
|
|
// Avant de répéter TOTALEMENT l'affichage en cours, on remet les variables à 0 et réinitialise le tableau de pointeurs
|
|
detruireCercles(*nbPointsAffiches, tabPointeursCercle);
|
|
*nbPointsAffiches = 0;
|
|
|
|
detruireCercles(*nbAgglosAffiches, tabPointeursCercleAgglos);
|
|
*nbAgglosAffiches = 0;
|
|
|
|
nbPtsNonAffiches = 0;
|
|
numAgglo = 0;
|
|
|
|
postAgglo = false;
|
|
|
|
free(tmpPtsAffiches);
|
|
tmpPtsAffiches = calloc(nbElements, sizeof(Point*));
|
|
|
|
i = 1;
|
|
|
|
resetTextureAndSpriteFromOriginal(renderTexture, &renderSprite, firstTexture);
|
|
updateAndDrawMenu(renderTexture, menu, MODE_PBP_AUTOMATIC, false, displayPaused, NO_TOOL);
|
|
sfRenderTexture_display(renderTexture);
|
|
sfTexture_destroy(originalTexture);
|
|
originalTexture = sfTexture_copy(sfRenderTexture_getTexture(renderTexture));
|
|
displayBackgroundSprite(window, renderSprite);
|
|
break;
|
|
|
|
case NO_TOOL:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(cancelDisplay)
|
|
{
|
|
Point **ptsAffiches = copieTabPointeurPt(tmpPtsAffiches, *nbPointsAffiches);
|
|
free(tmpPtsAffiches);
|
|
|
|
resetTextureAndSpriteFromOriginal(renderTexture, &renderSprite, originalTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
|
|
sfTexture_destroy(firstTexture);
|
|
sfTexture_destroy(originalTexture);
|
|
|
|
return ptsAffiches;
|
|
}
|
|
|
|
} while(displayPaused);
|
|
|
|
if(tabPoint[i].type != AGGLOMERAT)
|
|
{
|
|
if(i>0)
|
|
{
|
|
free(tabPointeursCercle[*nbPointsAffiches]);
|
|
dessinerPoint(renderTexture, tabPoint[i-1].posConv, &tabPointeursCercle[*nbPointsAffiches], COULEUR_POINT);
|
|
}
|
|
if(postAgglo)
|
|
{
|
|
dessinerAgglo(renderTexture, &agglos[numAgglo - 1], &tabPointeursCercleAgglos[*nbAgglosAffiches-1], nbPointAgglosMin, carte, COULEUR_AGGLO);
|
|
postAgglo = false;
|
|
}
|
|
tmpPtsAffiches[i - nbPtsNonAffiches] = tabPoint + i;
|
|
dessinerPoint(renderTexture, tabPoint[i].posConv, &tabPointeursCercle[(*nbPointsAffiches)++], COULEUR_POINT_ACTUEL);
|
|
}
|
|
else
|
|
{
|
|
dessinerAgglo(renderTexture, &agglos[numAgglo], &tabPointeursCercleAgglos[*nbAgglosAffiches], nbPointAgglosMin, carte, COULEUR_AGGLO_ACTUEL);
|
|
i += agglos[numAgglo].nbPts - 1;
|
|
nbPtsNonAffiches += agglos[numAgglo].nbPts;
|
|
(*nbAgglosAffiches)++;
|
|
numAgglo++;
|
|
postAgglo = true;
|
|
}
|
|
}
|
|
|
|
if(displayPaused)
|
|
{
|
|
resetTextureAndSpriteFromOriginal(renderTexture, &renderSprite, originalTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
}
|
|
|
|
sfTexture_destroy(firstTexture);
|
|
sfTexture_destroy(originalTexture);
|
|
|
|
sfRenderTexture_display(renderTexture);
|
|
|
|
freeSprite(&renderSprite);
|
|
renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
|
|
Point **ptsAffiches = copieTabPointeurPt(tmpPtsAffiches, *nbPointsAffiches);
|
|
free(tmpPtsAffiches);
|
|
freeSprite(&renderSprite);
|
|
return ptsAffiches;
|
|
}
|
|
|
|
|
|
Point** affichageLogsPBPManual(sfRenderWindow *const window, sfRenderTexture *renderTexture, Point *tabPoint, uint32_t nbElements, uint32_t *nbPointsAffiches, uint32_t nbPointAgglosMin, sfCircleShape *tabPointeursCercle[nbElements], Agglomerat *agglos, uint32_t nbAgglos, sfCircleShape *tabPointeursCercleAgglos[nbAgglos], uint32_t *const nbAgglosAffiches, const Carte *const carte, const Menu *const menu)
|
|
{
|
|
sfEvent event;
|
|
uint32_t nbPtsNonAffiches = 0;
|
|
*nbPointsAffiches = 0;
|
|
*nbAgglosAffiches = 0;
|
|
|
|
uint32_t numAgglo = 0;
|
|
|
|
sfSprite * renderSprite = NULL;
|
|
|
|
bool postAgglo = false;
|
|
|
|
Point** tmpPtsAffiches = calloc(nbElements, sizeof(Point*));
|
|
if(tmpPtsAffiches == NULL)
|
|
{
|
|
warningBox(window, renderSprite, strerror(errno));
|
|
freeSprite(&renderSprite);
|
|
return NULL;
|
|
}
|
|
|
|
// Booléens de gestion du menu !
|
|
bool cancelDisplay = false;
|
|
|
|
// Booléens d'optimisations graphiques !
|
|
bool descriptionEnLAir = false;
|
|
bool needToRefreshDisplay = false;
|
|
|
|
// Une texture pour copier celle de rendus à chaque itération (opération très lourde)
|
|
sfTexture *originalTexture = NULL;
|
|
|
|
// Une texture NON-MODIFIÉE qui fera juste office de "roll-back" si l'utilisateur répète l'afichage !
|
|
sfTexture *firstTexture = sfTexture_copy(sfRenderTexture_getTexture(renderTexture));
|
|
|
|
bool waitForNextPoint = false;
|
|
bool mouseWasPressed = false;
|
|
|
|
for(uint32_t i = 0; i < nbElements; i++)
|
|
{
|
|
// En mode point-par-point, il faut commencer par ré-afficher l'ancienne texture !
|
|
waitForNextPoint = !mouseWasPressed;
|
|
|
|
sfRenderTexture_display(renderTexture);
|
|
|
|
/* Cette ligne était manquante, il faut vérifier que les performances ne sont pas impactées et la garder (ou non) */
|
|
sfRenderWindow_clear(window, COULEUR_GRIS);
|
|
/* ______________________________________________________________________________________________________________ */
|
|
|
|
freeSprite(&renderSprite);
|
|
renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
sfRenderWindow_drawSprite(window, renderSprite, NULL);
|
|
|
|
sfRenderWindow_display(window);
|
|
|
|
// À chaque point supplémentaire, on effectue une petite pause pour avoir un affichage "homogène" sur toutes les plateformes d'exécution...
|
|
sfSleep((sfTime){DELAYPOINTBYPOINT});
|
|
|
|
// ... et on copie notre fameuse texture de rendus actuelle
|
|
originalTexture = sfTexture_copy(sfRenderTexture_getTexture(renderTexture));
|
|
|
|
do
|
|
{
|
|
while(sfRenderWindow_pollEvent(window, &event))
|
|
{
|
|
if(event.type == sfEvtClosed)
|
|
{
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
else if(event.type == sfEvtResized)
|
|
{
|
|
displayBackgroundSprite(window, renderSprite);
|
|
}
|
|
|
|
else if(event.type == sfEvtMouseMoved)
|
|
{
|
|
if(event.mouseMove.x >= WIDTH)
|
|
{
|
|
resetTextureAndSpriteFromOriginal(renderTexture, &renderSprite, originalTexture);
|
|
|
|
needToRefreshDisplay = afficherDescriptionBouton(&event, menu, renderTexture, &renderSprite);
|
|
|
|
if(needToRefreshDisplay)
|
|
{
|
|
descriptionEnLAir = true;
|
|
displayBackgroundSprite(window, renderSprite);
|
|
}
|
|
|
|
else if(descriptionEnLAir)
|
|
{
|
|
descriptionEnLAir = false;
|
|
displayBackgroundSprite(window, renderSprite);
|
|
}
|
|
}
|
|
else if(waitForNextPoint)
|
|
{
|
|
resetTextureAndSpriteFromOriginal(renderTexture, &renderSprite, originalTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
}
|
|
}
|
|
|
|
else if(event.type == sfEvtMouseButtonPressed || (mouseWasPressed && event.type != sfEvtMouseButtonReleased))
|
|
{
|
|
mouseWasPressed = true;
|
|
|
|
switch(whichTool(&event, menu))
|
|
{
|
|
case TOOL_EXIT:
|
|
exit(EXIT_SUCCESS);
|
|
|
|
case TOOL_BACKTOHOME:
|
|
free(tmpPtsAffiches);
|
|
return NULL;
|
|
|
|
case TOOL_GLOBAL:
|
|
cancelDisplay = true;
|
|
break;
|
|
|
|
case TOOL_CONTINUE:
|
|
waitForNextPoint = false;
|
|
break;
|
|
|
|
case TOOL_ERASE:
|
|
detruireCercles(*nbPointsAffiches, tabPointeursCercle);
|
|
*nbPointsAffiches = 0;
|
|
|
|
detruireCercles(*nbAgglosAffiches, tabPointeursCercleAgglos);
|
|
*nbAgglosAffiches = 0;
|
|
|
|
nbPtsNonAffiches = i;
|
|
|
|
postAgglo = false;
|
|
|
|
free(tmpPtsAffiches);
|
|
tmpPtsAffiches = calloc(nbElements, sizeof(Point*));
|
|
|
|
resetTextureAndSpriteFromOriginal(renderTexture, &renderSprite, firstTexture);
|
|
sfTexture_destroy(originalTexture);
|
|
originalTexture = sfTexture_copy(sfRenderTexture_getTexture(renderTexture));
|
|
displayBackgroundSprite(window, renderSprite);
|
|
break;
|
|
|
|
case TOOL_REPEAT:
|
|
// Avant de répéter TOTALEMENT l'affichage en cours, on remet les variables à 0 et réinitialise le tableau de pointeurs
|
|
detruireCercles(*nbPointsAffiches, tabPointeursCercle);
|
|
*nbPointsAffiches = 0;
|
|
|
|
detruireCercles(*nbAgglosAffiches, tabPointeursCercleAgglos);
|
|
*nbAgglosAffiches = 0;
|
|
|
|
nbPtsNonAffiches = 0;
|
|
|
|
postAgglo = false;
|
|
numAgglo = 0;
|
|
|
|
free(tmpPtsAffiches);
|
|
tmpPtsAffiches = calloc(nbElements, sizeof(Point*));
|
|
|
|
i = 0;
|
|
|
|
resetTextureAndSpriteFromOriginal(renderTexture, &renderSprite, firstTexture);
|
|
sfTexture_destroy(originalTexture);
|
|
originalTexture = sfTexture_copy(sfRenderTexture_getTexture(renderTexture));
|
|
displayBackgroundSprite(window, renderSprite);
|
|
break;
|
|
|
|
case NO_TOOL:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
mouseWasPressed = false;
|
|
}
|
|
}
|
|
|
|
if(cancelDisplay)
|
|
{
|
|
Point **ptsAffiches = copieTabPointeurPt(tmpPtsAffiches, *nbPointsAffiches);
|
|
free(tmpPtsAffiches);
|
|
|
|
resetTextureAndSpriteFromOriginal(renderTexture, &renderSprite, originalTexture);
|
|
sfTexture_destroy(originalTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
|
|
sfTexture_destroy(firstTexture);
|
|
|
|
return ptsAffiches;
|
|
}
|
|
|
|
} while(waitForNextPoint);
|
|
|
|
if(needToRefreshDisplay)
|
|
{
|
|
resetTextureAndSpriteFromOriginal(renderTexture, &renderSprite, originalTexture);
|
|
}
|
|
|
|
sfTexture_destroy(originalTexture);
|
|
|
|
if(tabPoint[i].type != AGGLOMERAT)
|
|
{
|
|
if(i>0)
|
|
{
|
|
free(tabPointeursCercle[*nbPointsAffiches]);
|
|
dessinerPoint(renderTexture, tabPoint[i-1].posConv, &tabPointeursCercle[*nbPointsAffiches], COULEUR_POINT);
|
|
}
|
|
if(postAgglo)
|
|
{
|
|
dessinerAgglo(renderTexture, &agglos[numAgglo - 1], &tabPointeursCercleAgglos[*nbAgglosAffiches - 1], nbPointAgglosMin, carte, COULEUR_AGGLO);
|
|
postAgglo = false;
|
|
}
|
|
tmpPtsAffiches[i - nbPtsNonAffiches] = tabPoint + i;
|
|
dessinerPoint(renderTexture, tabPoint[i].posConv, &tabPointeursCercle[(*nbPointsAffiches)++], COULEUR_POINT_ACTUEL);
|
|
}
|
|
else
|
|
{
|
|
dessinerAgglo(renderTexture, &agglos[numAgglo], &tabPointeursCercleAgglos[*nbAgglosAffiches], nbPointAgglosMin, carte, COULEUR_AGGLO_ACTUEL );
|
|
i += agglos[numAgglo].nbPts - 1;
|
|
nbPtsNonAffiches += agglos[numAgglo].nbPts;
|
|
(*nbAgglosAffiches)++;
|
|
numAgglo++;
|
|
postAgglo = true;
|
|
}
|
|
}
|
|
|
|
sfTexture_destroy(firstTexture);
|
|
|
|
sfRenderTexture_display(renderTexture);
|
|
|
|
freeSprite(&renderSprite);
|
|
renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
displayBackgroundSprite(window, renderSprite);
|
|
|
|
Point **ptsAffiches = copieTabPointeurPt(tmpPtsAffiches, *nbPointsAffiches);
|
|
free(tmpPtsAffiches);
|
|
freeSprite(&renderSprite);
|
|
return ptsAffiches;
|
|
}
|
|
|
|
|
|
uint32_t afficherDateSelectionnerPoint(sfEvent *event, sfRenderTexture *const renderTexture, sfSprite **renderSprite, const uint32_t nbPointsAffiches,Point ** ptsAffiches, sfCircleShape *tabPointeursCercles[nbPointsAffiches], Point * tabPoint, char **tabDatesConverties, const sfFont *font)
|
|
{
|
|
sfVector2f positionCercle;
|
|
sfText *texte = NULL;
|
|
|
|
for(uint32_t i = 0; i < nbPointsAffiches; i++)
|
|
{
|
|
if(tabPointeursCercles[i] == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
positionCercle = sfCircleShape_getPosition(tabPointeursCercles[i]);
|
|
|
|
if(mouseIsInCircle((sfVector2f){event->mouseMove.x - CIRCLERADIUS, event->mouseMove.y - CIRCLERADIUS}, (Cercle){positionCercle, CIRCLERADIUS}))
|
|
{
|
|
texte = creerTexte((sfVector2f){positionCercle.x + OFFSETFORDATE, positionCercle.y - OFFSETFORDATE}, tabDatesConverties[ptsAffiches[i]-tabPoint], font, 20, sfBlack);
|
|
sfRenderTexture_drawText(renderTexture, texte, NULL);
|
|
freeSprite(renderSprite);
|
|
*renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
sfText_destroy(texte);
|
|
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return nbPointsAffiches;
|
|
}
|
|
|
|
|
|
uint32_t selectionnerAgglomerats(sfEvent *event, const uint32_t nbAgglos, sfCircleShape *tabPointeursCerclesAgglos[nbAgglos],Agglomerat *agglos)
|
|
{
|
|
sfVector2f positionCercle;
|
|
|
|
for(uint32_t i = 0; i < nbAgglos; i++)
|
|
{
|
|
if(tabPointeursCerclesAgglos[i] == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
positionCercle = sfCircleShape_getPosition(tabPointeursCerclesAgglos[i]);
|
|
|
|
if(mouseIsInCircle((sfVector2f){event->mouseMove.x - agglos[i].tailleCercle, event->mouseMove.y - agglos[i].tailleCercle}, (Cercle){positionCercle, agglos[i].tailleCercle}))
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return nbAgglos;
|
|
}
|
|
|
|
|
|
bool afficherAdresseAgglomerats(const sfEvent *const event, sfRenderTexture *const renderTexture, sfSprite **renderSprite, const uint32_t tailleGlobalMultiFile, const AgglomeratGlobal globalMultiFile[tailleGlobalMultiFile], sfCircleShape **tabPointeursCerclesAgglos, const sfFont *const font)
|
|
{
|
|
sfVector2f positionCercle;
|
|
sfText *texte = NULL;
|
|
|
|
for(uint32_t i = 0; i < tailleGlobalMultiFile; i++)
|
|
{
|
|
if(tabPointeursCerclesAgglos[i] == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
positionCercle = sfCircleShape_getPosition(tabPointeursCerclesAgglos[i]);
|
|
|
|
if(mouseIsInCircle((sfVector2f){event->mouseMove.x - globalMultiFile[i].tailleCercle, event->mouseMove.y - globalMultiFile[i].tailleCercle}, (Cercle){positionCercle, globalMultiFile[i].tailleCercle}))
|
|
{
|
|
texte = creerTexte((sfVector2f){positionCercle.x + OFFSETFORDATE, positionCercle.y - OFFSETFORDATE}, globalMultiFile[i].adresse, font, 15, sfBlack);
|
|
sfRenderTexture_drawText(renderTexture, texte, NULL);
|
|
freeSprite(renderSprite);
|
|
*renderSprite = loadSpriteFromRenderTexture(renderTexture);
|
|
sfText_destroy(texte);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|