[SDL] Détecter l'appuies sur une touche

Marsh Posté le 20-01-2010 à 12:57:32

Bonjour,

J'ai un code tu type:

Code :

SDL_Event event;
while(continuer){
/*plein d'instructions*/
quitterOuEchap(&continuer, event);
}

Avec la fonction quitterOuEchap:

Code :

/*Procédure: vérifié si la touche echape est pressée ou si on a un évènement SDL_QUIT (clique sur la croix)
sans bloquer l'éxecution du programme
Données: Adresse de la varible de boucle et variable de l'évènement.
EB: mise à zéro de la variable si un des deux évènement est détecté.
Préconditions: avoir initialisé la SDL
*/
void quitterOuEchap(int *continuer, SDL_Event event)
{
SDL_PollEvent(&event);
switch(event.type){
case SDL_QUIT:
*continuer = 0;
break;
case SDL_KEYDOWN:
switch (event.key.keysym.sym){
case SDLK_ESCAPE:
*continuer = 0;
break;
default:
break;
}
break;
default:
break;
}
}

Malheureusement j'ai beau marteler la touche échap ou m'exciter sur la croix ça quitte pas, vous savez pourquoi ?

Merci.

Reply

Marsh Posté le 20-01-2010 à 12:57:32

Reply

Marsh Posté le 20-01-2010 à 13:02:30

Je ne vois pas trop à quoi te sert le passage d'évènement par valeur à ta fonction quitterOuEchap, sinon, ca m'a l'air ok.
Tu peux poser des breakpoints pour voir si tu arrives dans les fonctions qui t'intéressent et tracer ...

Est-ce que tu passes au moins dans ta fonction, déjà ? Parce que le code que tu ne nous montre pas pourrait bien contenir un continue qui va te la faire éviter ou quelque chose du genre.

---------------
last.fm

Reply

Marsh Posté le 20-01-2010 à 15:48:46

Hmm, j'imagine qu'il s'agisse du même programme que celui que tu as posté ici : http://forum.hardware.fr/hfr/Progr [...] 7182_1.htm

Parce que si c'est ça, ton problème se situe dans la fonction "appuisSurV()" dans lequel tu fais déjà un SQL_PollEvent, ce qui fait que la fonction suivante "quitterOuEchap()" n'aura plus rien à se mettre sous dent.

Arf, et je vois que fait une boucle d'attente avec un délai de 5ms (200 fps quand même). Sous Windows, si tu veux un délai aussi court, faut y aller bourrin, à coup de "while(getticks() - old < 5);". Les timer sous Windows on une précision de 10 à 15ms, soit tout juste bon pour faire du 50 à 60 fps.

Edit: je viens de voir plus en détail ta gestion des événements, et c'est pas trop ça. En général on ne fait qu'un seul appel à SQL_PollEvent ou SQL_WaitEvent et un seul switch sur "event.type". Après tu peux appeler d'autres fonctions dans les branches du switch.

Message cité 1 fois
Message édité par tpierron le 20-01-2010 à 15:57:22

Reply

Marsh Posté le 20-01-2010 à 17:53:47

Oui c'est bien le même programme.

Pour l'attente en fait je modifie la valeur en fonction du nombre de calculs que le programme doit effectuer. Ca me sert juste à ralentir le programme histoire de ne pas aller trop vite, et donc je m'en fiche de la précision.

Pour l'appel à SDL_WaitEvent, je le fais quand ?
Avant le while ?
Après je fais juste un switch sur event.type dans le while (donc dans ma fonction) ?

Reply

Marsh Posté le 20-01-2010 à 19:48:13

tpierron a écrit :

Parce que si c'est ça, ton problème se situe dans la fonction "appuisSurV()" dans lequel tu fais déjà un SQL_PollEvent, ce qui fait que la fonction suivante "quitterOuEchap()" n'aura plus rien à se mettre sous dent.

Mince j'ai lu trop rapidement et j'ai omis cette partie du message.

C'est effectivement ça, mais alors comment faire ?

Message édité par Cpowa le 20-01-2010 à 20:38:43

Reply

Marsh Posté le 20-01-2010 à 20:40:43

Bah c'est pas compliqué pourtant, il faut qu'il n'y ait qu'un seul appel à SDL_PollEvent() dans tout ton programme.

Donc appel cette fonction une seule fois et transmert la structure "event" à tes fonctions appuisSurV() ou quitterOuEchap(), du style (main.c) :

Code :

if (SDL_PollEvent(&event))
{
appuisSurV(&vecteur, event);
quitterOuEchap(&continuer, event);
}

Et enlève évidemment l'appel à SDL_PollEvent() dans les deux sous fonctions.

Message cité 1 fois
Message édité par tpierron le 20-01-2010 à 20:42:57

Reply

Marsh Posté le 20-01-2010 à 21:23:44

tpierron a écrit :

Bah c'est pas compliqué pourtant, il faut qu'il n'y ait qu'un seul appel à SDL_PollEvent() dans tout ton programme.

Donc appel cette fonction une seule fois et transmert la structure "event" à tes fonctions appuisSurV() ou quitterOuEchap(), du style (main.c) :

Code :

if (SDL_PollEvent(&event))
{
appuisSurV(&vecteur, event);
quitterOuEchap(&continuer, event);
}

Et enlève évidemment l'appel à SDL_PollEvent() dans les deux sous fonctions.

Magnifique, merci infiniment :jap: :jap:

Message édité par Cpowa le 20-01-2010 à 21:23:58

Reply

Marsh Posté le 21-01-2010 à 10:41:29

Une autre question, comment on utilise le débogueur de Code::Blocks ?

Dans projet->Build option j'ai bien coché "Produce debugging symbols" et j'ai mis un ponit d'arrêt dans le programme, mais quand je compile en lance en debug le logiciel ce lance normalement, il ne s'arrête pas au point d'arrêt....

Parce que j'ai un bug et je comprend vraiment pas d'où il vient......
Si vraiment je le trouve pas je posterais les sources mis à jour peut-etre que vous pourrez encore me sauver.

Message cité 1 fois

Reply

Marsh Posté le 21-01-2010 à 13:03:03

Tu as une barre d'outils debugger avec des boutons lancer, pas à pas, etc

Message cité 2 fois

---------------
deluser --remove-home ptitchep

Reply

Marsh Posté le 21-01-2010 à 13:07:41

ptitchep a écrit :

Tu as une barre d'outils debugger avec des boutons lancer, pas à pas, etc

Oui je sais, pour lancer je clique sur le bouton Debug/Continue mais ça me lance simplement le programme sans s'arrêter au point d'arrêt

Message cité 1 fois
Message édité par Cpowa le 21-01-2010 à 13:08:44

Reply

Marsh Posté le 21-01-2010 à 13:07:41

Reply

Marsh Posté le 21-01-2010 à 14:43:42

Cpowa a écrit :

Oui je sais, pour lancer je clique sur le bouton Debug/Continue mais ça me lance simplement le programme sans s'arrêter au point d'arrêt

ou tu ne mais pas de break-point
ou le code ne passe pas de cette break-point

avis personel (ne prener pas ca du coté negative) :
je vois quelque faiblaisse dans le program
meme si ca va marcher , il va te fatiguer
mieux avoir les chose plus simple et claire
(les nom de function, l'organization ... etc)

... :hello:

Message cité 1 fois

Reply

Marsh Posté le 21-01-2010 à 15:28:04

__tomjost a écrit :

ou tu ne mais pas de break-point
ou le code ne passe pas de cette break-point

le ponit d'arrêt est mis.
Et le code passe forcément par main .

__tomjost a écrit :

avis personel (ne prener pas ca du coté negative) :
je vois quelque faiblaisse dans le program
meme si ca va marcher , il va te fatiguer
mieux avoir les chose plus simple et claire
(les nom de function, l'organization ... etc)

... :hello:

oui là il est pas terminé, j'ai peaufiner et commenté.
Mais il me reste ce satané bug :fou: :fou: :fou: :fou: :fou: :fou: :fou: :fou: :fou:

Reply

Marsh Posté le 21-01-2010 à 15:48:37

quelque description de ce bug ?
quesqui ne marche pas ?

la ligne (ou 3) ou tu mais un break point ?

...(j'attend 5 minutes et je quitte :ange: )

Reply

Marsh Posté le 21-01-2010 à 16:48:43

Quand je met un point d'arrêt et que je clique sur Debug/Continue, ça me lance le programme et me grise toutes les commandes du debug (je ne peux plus cliquer dessus) et le programme ignore totalement le point d'arrêt.

Pour le bug j'explique le principe du programme:
Il simule l'évolution d'une boule accroché à un ressort (c'est comme un pendule sauf qu'on change la corde par un ressort).
Donc au début j'affiche la boule avec son ressort qui bougent, puis quand on appuye sur espace on passe dans le mode "trace". C'est à dire qu'on trace la trajectoire de la boule.
Tout fonctionne quand je met une masse.
Mais quand je met plus d'une masse, au début ça fonctionne je vois mes masses évoluer avec leurs ressorts. Mais quand je passe en mode trace j'obtiens une trajectoire tout droite, et je ne comprend pas pourquoi. Parce que le mode trace est exactement comme l'autre mode sauf qu'au lieu d'afficher la boule et le ressort, puis d'effacer l'écran, ré afficher la boule et le ressort effacer l'écran etc... et bien on affiche seulement un pixel à l'endroit de la boule sans effacer l'écran.

Que les deux modes ne fonctionnent pas ce serait compréhensible mais que seul le mode trace bug je ne comprend pas...

Je post mes sources à jour (sauf les header qui servent à rien). (attentions certains commentaires ne sont pas bon j'ai pas encore tout commenté)

main.c

Code :

#include <stdio.h>
#include <SDL/SDL.h>
#include "graphique.h"
#include <math.h>
#include "evenement.h"
#include "commun.h"
int main(int argc, char *argv[])
{
double point[NB_PROP][NBPART], ini[NB_PROP][NBPART];
int i, j, continuer1=1, continuer2=1, vecteur=1, pause=0;
SDL_Event event;
/*Initialisation de la SDL et ouverture de la fenêtre graphique avec redirection des erreurs vers la sortie standard*/
if(SDL_Init(SDL_INIT_VIDEO)==-1){
fprintf(stderr, "Erreur à l'initialisation de la SDL: %s \n", SDL_GetError());
exit(EXIT_FAILURE);
}
ecran=SDL_SetVideoMode(700, 700, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
if(ecran==NULL){
fprintf(stderr, "Erreur à l'initilisation du mode graphique: %s\n", SDL_GetError());
exit(EXIT_FAILURE);
}
SDL_WM_SetCaption("Pendule elastique", NULL);
/*#################################################################################################################*/
initCouleurs(ecran);
init(point, ecran);
for(i=0; i<NBPART; i++)
for(j=0; j<NB_PROP; j++)
ini[i][j]=point[i][j];
attendTouche();
/*--------=========#####Boucle principale du programme######========-------*/
while(continuer1==1 && continuer2==1){
effacerEcran();
for(i=0; i<NBPART; i++){
calculeAcc(i, point);
eulerPos(i, point);
eulerVit(i, point);
ligne(350, 250, point[POSX][i], point[POSY][i], couleurs[C_NOIR]);
}
affichePoint(point, vecteur);
disque(350,250, 3, couleurs[C_GRIS]);
SDL_Flip(ecran);
if (SDL_PollEvent(&event)){
appuisSurP(&pause, event);
appuisSurV(&vecteur, event);
appuisSurEspace(&continuer1, event);
quitterOuEchap(&continuer1, &continuer2, event);
}
if(pause){
attendTouche();
pause=0;
}
}
effacerEcran();
while(continuer2==1){
for(i=0; i<NBPART; i++){
calculeAcc(i, ini);
eulerPos(i, ini);
eulerVit(i, ini);
setPixelVerif(ini[POSX][i],ini[POSY][i], ini[COULEUR][i]);
}
disque(350,250, 3, couleurs[C_GRIS]);
SDL_Flip(ecran);
if (SDL_PollEvent(&event)){
quitterOuEchap(&continuer2, &continuer2, event);
appuisSurP(&pause, event);
}
if(pause){
attendTouche();
pause=0;
}
}
/*##################################################################################*/
SDL_Quit();
return EXIT_SUCCESS;
}

graphique.c

Code :

#include <SDL/SDL.h>
#include "graphique.h"
/*Procédure: Permet d'utiliser les couleurs plus facilement en appellant la fonction au début du programme
Données: Aucunes
Précondition: Avoir initialisé la SDL
*/
void initCouleurs(SDL_Surface *v_ecran)
{
couleurs[C_NOIR] = SDL_MapRGB(v_ecran->format, 0x00, 0x00, 0x00);
couleurs[C_BLEU_FONCE] = SDL_MapRGB(v_ecran->format, 0x00, 0x00, 0x80);
couleurs[C_VERT_FONCE] = SDL_MapRGB(v_ecran->format, 0x00, 0x80, 0x00);
couleurs[C_CYAN_FONCE] = SDL_MapRGB(v_ecran->format, 0x00, 0x80, 0x80);
couleurs[C_ROUGE_FONCE] = SDL_MapRGB(v_ecran->format, 0x80, 0x00, 0x00);
couleurs[C_MAGENTA_FONCE] = SDL_MapRGB(v_ecran->format, 0x80, 0x00, 0x80);
couleurs[C_OCRE] = SDL_MapRGB(v_ecran->format, 0x80, 0x80, 0x00);
couleurs[C_GRIS_CLAIR] = SDL_MapRGB(v_ecran->format, 0xC0, 0xC0, 0xC0);
couleurs[C_GRIS] = SDL_MapRGB(v_ecran->format, 0x80, 0x80, 0x80);
couleurs[C_BLEU] = SDL_MapRGB(v_ecran->format, 0x00, 0x00, 0xFF);
couleurs[C_VERT] = SDL_MapRGB(v_ecran->format, 0x00, 0xFF, 0x00);
couleurs[C_CYAN] = SDL_MapRGB(v_ecran->format, 0x00, 0xFF, 0xFF);
couleurs[C_ROUGE] = SDL_MapRGB(v_ecran->format, 0xFF, 0x00, 0x00);
couleurs[C_MAGENTA] = SDL_MapRGB(v_ecran->format, 0xFF, 0x00, 0xFF);
couleurs[C_JAUNE] = SDL_MapRGB(v_ecran->format, 0xFF, 0xFF, 0x00);
couleurs[C_BLANC] = SDL_MapRGB(v_ecran->format, 0xFF, 0xFF, 0xFF);
}
/*Procédure: Affiche un pixel de couleur donnée
Données: Coordonées du pixel et code couleur
Préconditions: Avoir initialisé la SDL et le mode graphique en 32bit,
les coordonnées du pixel doivent se situer dans la fenêtre
*/
void setPixel(int x, int y, Uint32 coul)
{
*((Uint32*)(POINTEUR_SURFACE->pixels) + x + y * POINTEUR_SURFACE->w) = coul;
}
/*Procédure: Affiche un pixel de couleur donnée de façon sécurisée
Données: Coordonées du pixel et code couleur
Préconditions: Avoir initialisé la SDL et le mode graphique en 32bit
*/
void setPixelVerif(int x, int y, Uint32 coul)
{
if (x >= 0 && x < POINTEUR_SURFACE->w &&
y >= 0 && y < POINTEUR_SURFACE->h)
setPixel(x, y, coul);
}
/*Procédure: Affiche une barre de dimensions données
Données: coordonnées du point supérieur gauche, largeur, hauteur et le code couleur.
Préconditions: Avoir initialisé la SDL et le mode graphique
*/
void barre(int x, int y, int w, int h, Uint32 coul)
{
SDL_Rect r;
r.x = x;
r.y = y;
r.w = w;
r.h = h;
SDL_FillRect(POINTEUR_SURFACE, &r, coul);
}
/*Procédure: Remplit la fenêtre en blanc
Données: Aucunes
Préconditions: Avoir initialisé la SDL et le mode graphique
*/
void effacerEcran(void)
{
SDL_FillRect(POINTEUR_SURFACE, NULL, couleurs[C_BLANC]);
}
/*Fonction: Echange deux variables d'entiers.
Données: deux entiers
Effet de bord: sur les deux variables
*/
void echangerEntiers(int* x, int* y)
{
int t = *x;
*x = *y;
*y = t;
}
/*Procédure: Trace une ligne quelconque
Données: Coordonnées du premier point, du second point et code couleur
Préconditions: Avoir initialisé la SDL et le mode graphique en 32 bit.
*/
void ligne(int x1, int y1, int x2, int y2, Uint32 coul)
{
int d, dx, dy, aincr, bincr, xincr, yincr, x, y;
if (abs(x2 - x1) < abs(y2 - y1)) {
/* parcours par l'axe vertical */
if (y1 > y2) {
echangerEntiers(&x1, &x2);
echangerEntiers(&y1, &y2);
}
xincr = x2 > x1 ? 1 : -1;
dy = y2 - y1;
dx = abs(x2 - x1);
d = 2 * dx - dy;
aincr = 2 * (dx - dy);
bincr = 2 * dx;
x = x1;
y = y1;
setPixelVerif(x, y, coul);
for (y = y1+1; y <= y2; ++y) {
if (d >= 0) {
x += xincr;
d += aincr;
} else
d += bincr;
setPixelVerif(x, y, coul);
}
} else {
/* parcours par l'axe horizontal */
if (x1 > x2) {
echangerEntiers(&x1, &x2);
echangerEntiers(&y1, &y2);
}
yincr = y2 > y1 ? 1 : -1;
dx = x2 - x1;
dy = abs(y2 - y1);
d = 2 * dy - dx;
aincr = 2 * (dy - dx);
bincr = 2 * dy;
x = x1;
y = y1;
setPixelVerif(x, y, coul);
for (x = x1+1; x <= x2; ++x) {
if (d >= 0) {
y += yincr;
d += aincr;
} else
d += bincr;
setPixelVerif(x, y, coul);
}
}
}
/*Procédure: Trace une ligne horizontale
Données: Coordonnées du point gauche, longueur de la ligne, code couleur
Préconditions: Avoir initialisé la SDL et le mode graphique
*/
void ligneHorizontale(int x, int y, int w, Uint32 coul)
{
SDL_Rect r;
r.x = x;
r.y = y;
r.w = w;
r.h = 1;
SDL_FillRect(POINTEUR_SURFACE, &r, coul);
}
/*Procédure: Trace un disque
Données: Coordonnées du centre, rayon et code couleur
Préconditions: Avoir initialisé la SDL et le mode graphique
*/
void disque(int cx, int cy, int rayon, int coul)
{
int d, y, x;
d = 3 - (2 * rayon);
x = 0;
y = rayon;
while (y >= x) {
ligneHorizontale(cx - x, cy - y, 2 * x + 1, coul);
ligneHorizontale(cx - x, cy + y, 2 * x + 1, coul);
ligneHorizontale(cx - y, cy - x, 2 * y + 1, coul);
ligneHorizontale(cx - y, cy + x, 2 * y + 1, coul);
if (d < 0)
d = d + (4 * x) + 6;
else {
d = d + 4 * (x - y) + 10;
y--;
}
x++;
}
}

evenement.c

Code :

#include <math.h>
#include <SDL/SDL.h>
#include "graphique.h"
#include "evenement.h"
#include "commun.h"
/*Procédure: Permet à l'utilisateur d'initialiser les particules (position, vitesse et rayon)
Données: Tableau, et adresse de la surface contenant l'écran
EB: modification des cases du tableau aux lignes indiquées
Précondition: Avoir initialisé la SDL
*/
void init(double point[NB_PROP][NBPART], SDL_Surface *ecran)
{
int i, x=0, y=0;
effacerEcran();
disque(350,250, 3, couleurs[C_GRIS]);
SDL_Flip(ecran);
for(i=0; i<NBPART; i++){
attendClicGauche(&x, &y);
if(i==0)
point[COULEUR][i]=couleurs[C_BLEU_FONCE];
else
point[COULEUR][i]=couleurs[C_MAGENTA_FONCE];
point[POSX][i]=x;
point[POSY][i]=y;
disque(point[POSX][i],point[POSY][i], 10, point[COULEUR][i]);
ligne(350, 250, point[POSX][i], point[POSY][i], couleurs[C_NOIR]);
SDL_Flip(ecran);
attendClicGauche(&x, &y);
point[VITX][i]=(x-point[POSX][i])/10;
point[VITY][i]=(y-point[POSY][i])/10;
afficheUneVitesse(point, i);
SDL_Flip(ecran);
point[ACCX][i]=0;
point[ACCY][i]=0;
point[MASSE][i]=0.1;
point[CONSTANTE_RAIDEUR][i]=50;
point[LONGUEUR_VIDE][i]=50;
}
}
/*Procédure: Affiche un vecteur vitesse depuis le centre d'un particule
Donnée: le tableau contenant les vitesses et la position et le n° de la colonne de la particule
EB: Auncun
Précondition: Avoir initialisé la SDL
*/
void afficheUneVitesse(double point[][NBPART], int j)
{
ligne(point[POSX][j], point[POSY][j],point[POSX][j]+point[VITX][j]*10,point[POSY][j]+point[VITY][j]*10, couleurs[C_ROUGE]);
}
/*Procédure: calcule la position d'une particule
Donné: indice de la particule et tableau où sont rangés les vitesses et les positions des particules
EB: modifie les cases correspondant aux positions dans le tableau des particules
Préconditions: Avoir initialisé la vitesse et la position des particules
*/
void calculeAcc(int indice, double point[][NBPART])
{
double l; /* longueur du ressort*/
l=sqrt((point[POSX][indice]-350)*(point[POSX][indice]-350)+(point[POSY][indice]-250)*(point[POSY][indice]-250));
point[ACCX][indice]=(-0.001*point[CONSTANTE_RAIDEUR][indice]/point[MASSE][indice])*(l-point[LONGUEUR_VIDE][indice])*((point[POSX][indice]-350)/l)-(COEF_FROTTEMENT/point[MASSE][indice])*point[VITX][indice];
point[ACCY][indice]=g+(-0.001*point[CONSTANTE_RAIDEUR][indice]/point[MASSE][indice])*(l-point[LONGUEUR_VIDE][indice])*((point[POSY][indice]-250)/l)-(COEF_FROTTEMENT/point[MASSE][indice])*point[VITY][indice];
}
void eulerVit(int indice, double point[][NBPART])
{
point[VITX][indice]=point[VITX][indice]+DT*point[ACCX][indice];
point[VITY][indice]=point[VITY][indice]+DT*point[ACCY][indice];
}
/*Procédure: calcule la position d'une particule
Donné: indice de la particule et tableau où sont rangés les vitesses et les positions des particules
EB: modifie les cases correspondant aux positions dans le tableau des particules
Préconditions: Avoir initialisé la vitesse et la position des particules
*/
void eulerPos(int indice, double point[][NBPART])
{
point[POSX][indice]=point[POSX][indice]+DT*point[VITX][indice]*1000;
point[POSY][indice]=point[POSY][indice]+DT*point[VITY][indice]*1000;
}
/*void verletVit(int indice, double point[][NBPART])
{
point[VITX][indice]=point[VITX][indice]+DT*(point[ACCX][indice];
point[VITY][indice]=point[VITY][indice]+DT*point[ACCY][indice];
}*/
/*Procédure: Affiche toutes les particules avec leur vecteurs vitesse ou non
Données: tableau où sont stockés la position et le vecteur vitesse des particules
booléen pour le cercle et le vecteur
EB: aucun
Préconditions: avoir initialisé la vitesse et la position des particules ainsi que la SDL.
*/
void affichePoint(double point[][NBPART], int Vecteur)
{
int i;
for(i=0; i<NBPART; i++){
disque(point[POSX][i],point[POSY][i], 10, point[COULEUR][i]);
if(Vecteur)
afficheUneVitesse(point, i);
}
}
/*Procédure: vérifié si la touche echape est pressée ou si on a un évènement SDL_QUIT (clique sur la croix)
sans bloquer l'éxecution du programme
Données: Adresse de la varible de boucle et variable de l'évènement.
EB: mise à zéro de la variable si un des deux évènement est détecté.
Préconditions: avoir initialisé la SDL
*/
void quitterOuEchap(int *continuer1,int *continuer2, SDL_Event event)
{
switch(event.type){
case SDL_QUIT:
*continuer1 = 0;
*continuer2 = 0;
break;
case SDL_KEYDOWN:
switch (event.key.keysym.sym){
case SDLK_ESCAPE:
*continuer1 = 0;
*continuer2 = 0;
break;
default:
break;
}
break;
default:
break;
}
}
void appuisSurV(int *vecteur, SDL_Event event)
{
switch(event.type){
case SDL_KEYDOWN:
switch (event.key.keysym.sym){
case SDLK_v:
if(*vecteur == 1)
*vecteur=0;
else
*vecteur=1;
break;
default:
break;
}
break;
default:
break;
}
}
void appuisSurP(int *pause, SDL_Event event)
{
switch(event.type){
case SDL_KEYDOWN:
switch (event.key.keysym.sym){
case SDLK_p:
if(*pause == 1)
*pause=0;
else
*pause=1;
break;
default:
break;
}
break;
default:
break;
}
}
void appuisSurEspace(int *continuer1, SDL_Event event)
{
switch(event.type){
case SDL_KEYDOWN:
switch (event.key.keysym.sym){
case SDLK_SPACE:
if(*continuer1 == 1)
*continuer1=0;
else
*continuer1=1;
break;
default:
break;
}
break;
default:
break;
}
}
/*Procédure: Attend jusqu'à l'appuie sur une touche
Précondition: Avoir initialisé la SDL
*/
void attendTouche(void)
{
int continuer=1;
SDL_Event event;
while (continuer){
SDL_WaitEvent(&event);
switch(event.type){
case SDL_KEYDOWN:
continuer = 0;
break;
default:
break;
}
}
}
/*Procédure: Attend l'évènement clic gauche et donne la position du clic
Données: adresse de la varible position x et de la varible position y
EB: modification de la valeur des variables
Précondition: Avoir initialisé la SDL
*/
void attendClicGauche(int *x, int *y)
{
int continuer = 1;
SDL_Event event;
while (continuer){
SDL_WaitEvent(&event);
switch(event.type){
case SDL_MOUSEBUTTONUP:
if (event.button.button == SDL_BUTTON_LEFT){
*x = event.button.x;
*y = event.button.y;
continuer = 0;
}
break;
default:
break;
}
}
}

Message cité 1 fois

Reply

Marsh Posté le 21-01-2010 à 17:53:58

Cpowa a écrit :

main.c

Code :

/*--------=========#####Boucle principale du programme######========-------*/
while(continuer1==1 && continuer2==1){
effacerEcran();
for(i=0; i<NBPART; i++){
calculeAcc(i, point);
eulerPos(i, point);
eulerVit(i, point);
ligne(350, 250, point[POSX][i], point[POSY][i], couleurs[C_NOIR]);
}
affichePoint(point, vecteur);
disque(350,250, 3, couleurs[C_GRIS]);
SDL_Flip(ecran);
if (SDL_PollEvent(&event)){
appuisSurP(&pause, event);
appuisSurV(&vecteur, event);
appuisSurEspace(&continuer1, event);
quitterOuEchap(&continuer1, &continuer2, event);
}
if(pause){
attendTouche();
pause=0;
}
}
effacerEcran();
while(continuer2==1){
for(i=0; i<NBPART; i++){
calculeAcc(i, ini);
eulerPos(i, ini);
eulerVit(i, ini);
setPixelVerif(ini[POSX][i],ini[POSY][i], ini[COULEUR][i]);
}
disque(350,250, 3, couleurs[C_GRIS]);
SDL_Flip(ecran);
if (SDL_PollEvent(&event)){
quitterOuEchap(&continuer2, &continuer2, event);
appuisSurP(&pause, event);
}
if(pause){
attendTouche();
pause=0;
}
}
/*##################################################################################*/

C'est quoi continuer1 et continuer2
Pourquoi dans ta boucle principale tu as 2 while non imbriqué? (parce que la ca fait 2 boucles...)

Message édité par breizhbugs le 21-01-2010 à 17:54:34

Reply

Marsh Posté le 21-01-2010 à 17:59:41

Première boucle: affichage normal
Deuxième boucle: affichage en mode trace.
Donc les deux boucles sont identiques sauf que dans l'une on affiche que des pixels.

continuer1 et continuer2 pour pouvoir sortir des deux boucles si on veut quitter le programme.

Reply

Marsh Posté le 21-01-2010 à 20:20:56

Cpowa a écrit :

Une autre question, comment on utilise le débogueur de Code::Blocks ?

Dans projet->Build option j'ai bien coché "Produce debugging symbols" et j'ai mis un ponit d'arrêt dans le programme, mais quand je compile en lance en debug le logiciel ce lance normalement, il ne s'arrête pas au point d'arrêt....

Parce que j'ai un bug et je comprend vraiment pas d'où il vient......
Si vraiment je le trouve pas je posterais les sources mis à jour peut-etre que vous pourrez encore me sauver.

ptitchep a écrit :

Tu as une barre d'outils debugger avec des boutons lancer, pas à pas, etc

Dev-Cpp

Sinon j'ai le même problème perso, la barre d'outils qui s'appelle "Debug" sous Code::Blocks contient des élements grisés (tout le temps), et le programme ne s'arrête pas aux points d'arrêt.

Reply

Marsh Posté le 21-01-2010 à 20:49:56

dev-cpp n'ets plus trop maintenu :s

Reply

Marsh Posté le 21-01-2010 à 22:33:45

:sol: c'est peut etre un composant du coordonne qui prend zero...

pour les break-point:
tout simplement , il n'ya pas debug-info , ni symbol ni text!
je ne connait pas ce "Dev-Cpp" mais
voir si il ya d'autre option qui controle ca ,
on choisie le type du debug ...etc

Reply

Marsh Posté le 22-01-2010 à 10:42:53

Je n'ai jamais rien debuggé dans code::blocks, même si je l'utilise pour coder. Ca n'a jamais vraiment marché correctement: il ignorait des points d'arret pour moi aussi et même parfois freezait completement, par exemple avec des programmes OpenGL... Je pense que cela vient d'une utilisation bizarre de gdb car je n'ai pas de problème avec d'autre debuggers.
Sous Linux j'ai kdbg qui ne tourne pas trop mal mais n'importe quelle couche graphique de gdb fait l'affaire(hors code::blocks ). Sous Windows, je n'ai pas de solution. Les rares fois où j'en ai besoin j'utilise visual studio et je dois reconnaitre que le peu que j'en ai vu le place pour moi n°1 des debugger.

---------------
deluser --remove-home ptitchep

Reply

[SDL] Détecter l'appuies sur une touche

Sujets relatifs:

Leave a Replay