[C/SDL] undefined reference to mes fonction

undefined reference to mes fonction [C/SDL] - C - Programmation

Marsh Posté le 19-01-2010 à 19:03:54    

Salut,
 
J'ai des erreurs à la compilation de mon programme:

Code :
  1. ||=== pendule, Debug ===|
  2. obj\Debug\main.o||In function `SDL_main':|
  3. taire\Bureau\pendule\main.c|36|undefined reference to `_affichePoint'|
  4. taire\Bureau\pendule\main.c|49|undefined reference to `_calculeAcc'|
  5. taire\Bureau\pendule\main.c|50|undefined reference to `_eulerVit'|
  6. taire\Bureau\pendule\main.c|51|undefined reference to `_eulerPos'|
  7. taire\Bureau\pendule\main.c|56|undefined reference to `_affichePoint'|
  8. obj\Debug\evenement.o||In function `affichePoint.4':|
  9. taire\Bureau\pendule\evenement.c|135|undefined reference to `_disque'|
  10. ||=== Build finished: 6 errors, 0 warnings ===|


 
Je compile avec code::blocks, Le projet est bien en mode realase et debug, ainsi que tout mes fichiers.
 
Voici mes sources:
main.c

Code :
  1. #include <stdio.h>
  2. #include <SDL/SDL.h>
  3. #include "graphique.h"
  4. #include <math.h>
  5. #include "evenement.h"
  6. #include "commun.h"
  9. int main(int argc, char *argv[])
  11. {
  12.   double point[NB_PROP][NBPART];
  13.   int  i, continuer=1, vecteur=0;
  14.   SDL_Event event;
  17. /*Initialisation de la SDL et ouverture de la fenêtre graphique avec redirection des erreurs vers la sortie standard*/
  18.   if(SDL_Init(SDL_INIT_VIDEO)==-1){
  19.     fprintf(stderr, "Erreur à l'initialisation de la SDL: %s \n", SDL_GetError());
  20.     exit(EXIT_FAILURE);
  21.   }
  23.   ecran=SDL_SetVideoMode(800, 800, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
  24.   if(ecran==NULL){
  25.     fprintf(stderr, "Erreur à l'initilisation du mode graphique: %s\n", SDL_GetError());
  26.     exit(EXIT_FAILURE);
  27.   }
  28.   SDL_WM_SetCaption("Pendule élastique", NULL);
  30. /*#################################################################################################################*/
  32.   initCouleurs(ecran);
  33.   effacerEcran();
  34.   init(point, ecran);
  36.   affichePoint(point, vecteur);
  39.   SDL_Flip(ecran);
  40.   attendTouche();
  44. /*--------=========#####Boucle principale du programme######========-------*/
  45.   while(continuer){
  48.     for(i=0; i<NBPART; i++){
  49.       calculeAcc(i, point);
  50.       eulerVit(i, point);
  51.       eulerPos(i, point);
  52.     }
  53.                                            /*On calcul les positions*/
  55.     effacerEcran();
  56.     affichePoint(point, vecteur);
  57.     ligne(400, 400, point[POSX][0], point[POSY][0], couleurs[C_NOIR]);                    /*On affiche les particules */
  58.     ligne(point[POSX][0], point[POSY][0], point[POSX][1], point[POSY][1], couleurs[C_NOIR]);
  60.     SDL_Flip(ecran);
  63.     SDL_Delay(DELAI_MS);
  64.     appuisSurV(&vecteur, event);
  65.     quitterOuEchap(&continuer, event);
  69.   }
  70. /*##################################################################################*/
  72.   SDL_Quit();
  75.   return EXIT_SUCCESS;
  76. }


 
graphique.c

Code :
  1. #include <SDL/SDL.h>
  2. #include "graphique.h"
  5. /*Procédure: Permet d'utiliser les couleurs plus facilement en appellant la fonction au début du programme
  6.   Données: Aucunes
  7.   Précondition: Avoir initialisé la SDL
  8. */
  9. void initCouleurs(SDL_Surface *v_ecran)
  10. {
  11.   couleurs[C_NOIR]          = SDL_MapRGB(v_ecran->format, 0x00, 0x00, 0x00);
  12.   couleurs[C_BLEU_FONCE]    = SDL_MapRGB(v_ecran->format, 0x00, 0x00, 0x80);
  13.   couleurs[C_VERT_FONCE]    = SDL_MapRGB(v_ecran->format, 0x00, 0x80, 0x00);
  14.   couleurs[C_CYAN_FONCE]    = SDL_MapRGB(v_ecran->format, 0x00, 0x80, 0x80);
  15.   couleurs[C_ROUGE_FONCE]   = SDL_MapRGB(v_ecran->format, 0x80, 0x00, 0x00);
  16.   couleurs[C_MAGENTA_FONCE] = SDL_MapRGB(v_ecran->format, 0x80, 0x00, 0x80);
  17.   couleurs[C_OCRE]          = SDL_MapRGB(v_ecran->format, 0x80, 0x80, 0x00);
  18.   couleurs[C_GRIS_CLAIR]    = SDL_MapRGB(v_ecran->format, 0xC0, 0xC0, 0xC0);
  19.   couleurs[C_GRIS]          = SDL_MapRGB(v_ecran->format, 0x80, 0x80, 0x80);
  20.   couleurs[C_BLEU]          = SDL_MapRGB(v_ecran->format, 0x00, 0x00, 0xFF);
  21.   couleurs[C_VERT]          = SDL_MapRGB(v_ecran->format, 0x00, 0xFF, 0x00);
  22.   couleurs[C_CYAN]          = SDL_MapRGB(v_ecran->format, 0x00, 0xFF, 0xFF);
  23.   couleurs[C_ROUGE]         = SDL_MapRGB(v_ecran->format, 0xFF, 0x00, 0x00);
  24.   couleurs[C_MAGENTA]       = SDL_MapRGB(v_ecran->format, 0xFF, 0x00, 0xFF);
  25.   couleurs[C_JAUNE]         = SDL_MapRGB(v_ecran->format, 0xFF, 0xFF, 0x00);
  26.   couleurs[C_BLANC]         = SDL_MapRGB(v_ecran->format, 0xFF, 0xFF, 0xFF);
  27. }
  29. /*Procédure: Affiche un pixel de couleur donnée
  30.   Données: Coordonées du pixel et code couleur
  31.   Préconditions: Avoir initialisé la SDL et le mode graphique en 32bit,
  32.                 les coordonnées du pixel doivent se situer dans la fenêtre
  33. */
  34. void setPixel(int x, int y, Uint32 coul)
  35. {
  36.   *((Uint32*)(POINTEUR_SURFACE->pixels) + x + y * POINTEUR_SURFACE->w) = coul;
  37. }
  40. /*Procédure: Affiche un pixel de couleur donnée de façon sécurisée
  41.   Données: Coordonées du pixel et code couleur
  42.   Préconditions: Avoir initialisé la SDL et le mode graphique en 32bit
  43. */
  44. void setPixelVerif(int x, int y, Uint32 coul)
  45. {
  46.   if (x >= 0 && x < POINTEUR_SURFACE->w &&
  47.       y >= 0 && y < POINTEUR_SURFACE->h)
  48.     setPixel(x, y, coul);
  49. }
  50. /*Procédure: Affiche une barre de dimensions données
  51.   Données: coordonnées du point supérieur gauche, largeur, hauteur et le code couleur.
  52.   Préconditions: Avoir initialisé la SDL et le mode graphique
  53. */
  54. void barre(int x, int y, int w, int h, Uint32 coul)
  55. {
  56.   SDL_Rect r;
  58.   r.x = x;
  59.   r.y = y;
  60.   r.w = w;
  61.   r.h = h;
  63.   SDL_FillRect(POINTEUR_SURFACE, &r, coul);
  64. }
  66. /*Procédure: Remplit la fenêtre en blanc
  67.   Données: Aucunes
  68.   Préconditions: Avoir initialisé la SDL et le mode graphique
  69. */
  70. void effacerEcran(void)
  71. {
  72.   SDL_FillRect(POINTEUR_SURFACE, NULL, couleurs[C_BLANC]);
  73. }
  76. /*Fonction: Echange deux variables d'entiers.
  77.   Données: deux entiers
  78.   Effet de bord: sur les deux variables
  79. */
  80. void echangerEntiers(int* x, int* y)
  81. {
  82.   int t = *x;
  83.   *x = *y;
  84.   *y = t;
  85. }
  87. /*Procédure: Trace une ligne quelconque
  88.   Données: Coordonnées du premier point, du second point et code couleur
  89.   Préconditions: Avoir initialisé la SDL et le mode graphique en 32 bit.
  90. */
  91. void ligne(int x1, int y1, int x2, int y2, Uint32 coul)
  92. {
  93.   int d, dx, dy, aincr, bincr, xincr, yincr, x, y;
  95.   if (abs(x2 - x1) < abs(y2 - y1)) {
  96.     /* parcours par l'axe vertical */
  98.     if (y1 > y2) {
  99.       echangerEntiers(&x1, &x2);
  100.       echangerEntiers(&y1, &y2);
  101.     }
  103.     xincr = x2 > x1 ? 1 : -1;
  104.     dy = y2 - y1;
  105.     dx = abs(x2 - x1);
  106.     d = 2 * dx - dy;
  107.     aincr = 2 * (dx - dy);
  108.     bincr = 2 * dx;
  109.     x = x1;
  110.     y = y1;
  112.     setPixelVerif(x, y, coul);
  114.     for (y = y1+1; y <= y2; ++y) {
  115.       if (d >= 0) {
  116. x += xincr;
  117. d += aincr;
  118.       } else
  119. d += bincr;
  121.       setPixelVerif(x, y, coul);
  122.     }
  124.   } else {
  125.     /* parcours par l'axe horizontal */
  127.     if (x1 > x2) {
  128.       echangerEntiers(&x1, &x2);
  129.       echangerEntiers(&y1, &y2);
  130.     }
  132.     yincr = y2 > y1 ? 1 : -1;
  133.     dx = x2 - x1;
  134.     dy = abs(y2 - y1);
  135.     d = 2 * dy - dx;
  136.     aincr = 2 * (dy - dx);
  137.     bincr = 2 * dy;
  138.     x = x1;
  139.     y = y1;
  141.     setPixelVerif(x, y, coul);
  143.     for (x = x1+1; x <= x2; ++x) {
  144.       if (d >= 0) {
  145. y += yincr;
  146. d += aincr;
  147.       } else
  148. d += bincr;
  150.       setPixelVerif(x, y, coul);
  151.     }
  152.   }
  153. }
  157. /*Procédure: Trace un cercle
  158.   Données: Coordonnées du centre, rayon et code couleur
  159.   Préconditions: Avoir initialisé la SDL et le mode graphique en 32bit,
  160. */
  161. void cercle(int cx, int cy, int rayon, int coul)
  162. {
  163.   int d, y, x;
  165.   d = 3 - (2 * rayon);
  166.   x = 0;
  167.   y = rayon;
  169.   while (y >= x) {
  170.     setPixelVerif(cx + x, cy + y, coul);
  171.     setPixelVerif(cx + y, cy + x, coul);
  172.     setPixelVerif(cx - x, cy + y, coul);
  173.     setPixelVerif(cx - y, cy + x, coul);
  174.     setPixelVerif(cx + x, cy - y, coul);
  175.     setPixelVerif(cx + y, cy - x, coul);
  176.     setPixelVerif(cx - x, cy - y, coul);
  177.     setPixelVerif(cx - y, cy - x, coul);
  179.     if (d < 0)
  180.       d = d + (4 * x) + 6;
  181.     else {
  182.       d = d + 4 * (x - y) + 10;
  183.       y--;
  184.     }
  186.     x++;
  187.   }
  188. }


 
graphique.h

Code :
  1. #ifndef GRAPHIQUE_H
  2. #define GRAPHIQUE_H
  3. /*nom du pointeur (de type SDL_Surface) qui va stocker la surface qui correspond à toute la fenêtre,
  4.   utilisé dans quasiment toutes les fonctions de ce fichier. Il faudra donc pour utiliser la plupart
  5.   des modules de ce fichier récupérer le pointeur renvoyé par SDL_SetVideoMode
  6. */
  7. #define POINTEUR_SURFACE ecran
  8. enum
  9. {
  10.   C_NOIR, C_BLEU_FONCE, C_VERT_FONCE, C_CYAN_FONCE, C_ROUGE_FONCE,
  11.   C_MAGENTA_FONCE, C_OCRE, C_GRIS_CLAIR, C_GRIS, C_BLEU, C_VERT,
  12.   C_CYAN, C_ROUGE, C_MAGENTA, C_JAUNE, C_BLANC,
  14.   NB_COULEURS
  15. };
  16. SDL_Surface* POINTEUR_SURFACE;
  17. Uint32 couleurs[NB_COULEURS]; /*tableau global servant à la fonction  InitCouleurs()*/
  19. /*Procédure: Permet d'utiliser les couleurs plus facilement en appellant la fonction au début du programme
  20.   Données: Aucunes
  21.   Précondition: Avoir initialisé la SDL
  22. */
  23. void initCouleurs(SDL_Surface *v_ecran);
  26. /*Procédure: Affiche un pixel de couleur donnée
  27.   Données: Coordonées du pixel et code couleur
  28.   Préconditions: Avoir initialisé la SDL et le mode graphique en 32bit,
  29.                 les coordonnées du pixel doivent se situer dans la fenêtre
  30. */
  31. void setPixel(int x, int y, Uint32 coul);
  33. /*Procédure: Affiche un pixel de couleur donnée de façon sécurisée
  34.   Données: Coordonées du pixel et code couleur
  35.   Préconditions: Avoir initialisé la SDL et le mode graphique en 32bit
  36. */
  37. void setPixelVerif(int x, int y, Uint32 coul);
  39. /*Procédure: Affiche une barre de dimensions données
  40.   Données: coordonnées du point supérieur gauche, largeur, hauteur et le code couleur.
  41.   Préconditions: Avoir initialisé la SDL et le mode graphique
  42. */
  43. void barre(int x, int y, int w, int h, Uint32 coul);
  45. /*Procédure: Remplit la fenêtre en blanc
  46.   Données: Aucunes
  47.   Préconditions: Avoir initialisé la SDL et le mode graphique
  48. */
  49. void effacerEcran(void);
  52. /*Fonction: Echange deux variables d'entiers.
  53.   Données: deux entiers
  54.   Effet de bord: sur les deux variables
  55. */
  56. void echangerEntiers(int* x, int* y);
  58. /*Procédure: Trace une ligne quelconque
  59.   Données: Coordonnées du premier point, du second point et code couleur
  60.   Préconditions: Avoir initialisé la SDL et le mode graphique en 32 bit.
  61. */
  62. void ligne(int x1, int y1, int x2, int y2, Uint32 coul);
  65. /*Procédure: Trace un cercle
  66.   Données: Coordonnées du centre, rayon et code couleur
  67.   Préconditions: Avoir initialisé la SDL et le mode graphique en 32bit,
  68. */
  69. void cercle(int cx, int cy, int rayon, int coul);
  74. #endif


 
evenement.c

Code :
  1. #include <math.h>
  2. #include <SDL/SDL.h>
  3. #include "graphique.h"
  4. #include "evenement.h"
  5. #include "commun.h"
  9. /*Procédure: Permet à l'utilisateur d'initialiser les particules (position, vitesse et rayon)
  10.   Données: Tableau, et adresse de la surface contenant l'écran
  11.   EB: modification des cases du tableau aux lignes indiquées
  12.   Précondition: Avoir initialisé la SDL
  13. */
  14. void init(double point[][NBPART], SDL_Surface *ecran)
  15. {
  17.   int  i;
  18.   double x, y, vx, vy, masse, constante_raideur, longueur_vide;
  21.   for(i=0; i<NBPART; i++){
  23.   /*  printf("Position initiale en cm x,y \n" );
  24.     scanf("%lf", &x);
  25.     scanf("%lf", &y);
  27.     point[POSX][i]=x;
  28.     point[POSY][i]=y;
  31.     printf("Vitesse initiale en m/s x,y \n" );
  32.     scanf("%lf", &vx);
  33.     scanf("%lf", &vy);
  35.     point[VITX][i]=vx;
  36.     point[VITY][i]=vy;
  40.     printf("Masse en kg \n" );
  41.     scanf("%lf", &masse);
  42.     nuage[MASSE][i]=masse;
  44.     printf("Constante de raideur en N/m \n" );
  45.     scanf("%lf", &constante_raideur);
  46.     point[CONSTANTE_RAIDEUR][i]=constante_raideur;
  48.     printf("longueur a vide en cm \n" );
  49.     scanf("%lf", &longueur_vide);
  50.     point[LONGUEUR_VIDE][i]=longueur_vide;
  53.     point[COULEUR][i]=couleurs[C_ROUGE];
  54.     point[ACCX][i]=0;
  55.     point[ACCY][i]=0;
  56.     */
  59.     point[POSX][i]=600;
  60.     point[POSY][i]=400;
  62.     point[VITX][i]=0;
  63.     point[VITY][i]=0;
  65.     point[ACCX][i]=0;
  66.     point[ACCY][i]=0;
  68.     point[MASSE][i]=1;
  69.     point[COULEUR][i]=couleurs[C_CYAN];
  71.     point[CONSTANTE_RAIDEUR][i]=50;
  73.     point[LONGUEUR_VIDE][i]=100;
  74. }
  80. /*Procédure: Affiche un vecteur vitesse depuis le centre d'un particule
  81.   Donnée: le tableau contenant les vitesses et la position et le n° de la colonne de la particule
  82.   EB: Auncun
  83.   Précondition: Avoir initialisé la SDL
  84. */
  85. void afficheUneVitesse(double point[][NBPART], int j)
  86. {
  87.   ligne(point[POSX][j], point[POSY][j],point[POSX][j]+point[VITX][j],point[POSY][j]+point[VITY][j],  couleurs[C_JAUNE]);
  88. }
  92. /*Procédure: calcule la position d'une particule
  93.   Donné: indice de la particule et tableau où sont rangés les vitesses et les positions des particules
  94.   EB: modifie les cases correspondant aux positions dans le tableau des particules
  95.   Préconditions: Avoir initialisé la vitesse et la position des particules
  96. */
  97. void calculeAcc(int indice, double point[][NBPART])
  98. {
  99.   point[ACCX][indice]=(-1*point[CONSTANTE_RAIDEUR][indice]/point[MASSE][indice])*(sqrt((point[POSX][indice]-400)*(point[POSX][indice]-400)+(point[POSY][indice]-400)*(point[POSY][indice]-400))-point[LONGUEUR_VIDE][indice])*((point[POSX][indice]-400)/sqrt((point[POSX][indice]-400)*(point[POSX][indice]-400)+(point[POSY][indice]-400)*(point[POSY][indice]-400)))-(COEF_FROTTEMENT/point[MASSE][indice])*point[VITX][indice];
  100.   point[ACCY][indice]=g-(-1*point[CONSTANTE_RAIDEUR][indice]/point[MASSE][indice])*(sqrt((point[POSX][indice]-400)*(point[POSX][indice]-400)+(point[POSY][indice]-400)*(point[POSY][indice]-400))-point[LONGUEUR_VIDE][indice])*((point[POSY][indice]-400)/sqrt((point[POSX][indice]-400)*(point[POSX][indice]-400)+(point[POSY][indice]-400)*(point[POSY][indice]-400)))-(COEF_FROTTEMENT/point[MASSE][indice])*point[VITY][indice];
  102. }
  105. void eulerVit(int indice, double point[][NBPART])
  106. {
  107.   point[VITX][indice]=point[VITX][indice]+DT*point[ACCX][indice];
  108.   point[VITY][indice]=point[VITY][indice]+DT*point[ACCY][indice];
  109. }
  112. /*Procédure: calcule la position d'une particule
  113.   Donné: indice de la particule et tableau où sont rangés les vitesses et les positions des particules
  114.   EB: modifie les cases correspondant aux positions dans le tableau des particules
  115.   Préconditions: Avoir initialisé la vitesse et la position des particules
  116. */
  117. void eulerPos(int indice, double point[][NBPART])
  118. {
  119.   point[POSX][indice]=point[POSX][indice]+DT*point[VITX][indice];
  120.   point[POSY][indice]=point[POSY][indice]+DT*point[VITY][indice];
  121. }
  124. /*Procédure: Affiche toutes les particules avec leur vecteurs vitesse ou non
  125.   Données: tableau où sont stockés la position et le vecteur vitesse des particules
  126.            booléen pour le cercle et le vecteur
  127.   EB: aucun
  128.   Préconditions: avoir initialisé la vitesse et la position des particules ainsi que la SDL.
  129. */
  130. void affichePoint(double point[][NBPART], int Vecteur)
  131. {
  132.   int i;
  134.   for(i=0; i<NBPART; i++){
  135.     disque(point[POSX][i],point[POSY][i], 10, point[COULEUR][i]);
  137.     }
  141.     if(Vecteur)
  142.       afficheUneVitesse(point, i);
  143.   }
  145. }
  150. /*Procédure: vérifié si la touche echape est pressée ou si on a un évènement SDL_QUIT (clique sur la croix)
  151.              sans bloquer l'éxecution du programme
  152.   Données: Adresse de la varible de boucle et variable de l'évènement.
  153.   EB: mise à zéro de la variable si un des deux évènement est détecté.
  154.   Préconditions: avoir initialisé la SDL
  155. */
  156. void quitterOuEchap(int *continuer, SDL_Event event)
  157. {
  158.   SDL_PollEvent(&event);
  159.   switch(event.type){
  160.     case SDL_QUIT:
  161.       *continuer = 0;
  162.        break;
  163.     case SDL_KEYDOWN:
  164.       switch (event.key.keysym.sym){
  165.         case SDLK_ESCAPE:
  166.           *continuer = 0;
  167.           break;
  168.       }
  169.        break;
  170.   }
  171. }
  173. void appuisSurV(int *vecteur, SDL_Event event)
  174. {
  175.   SDL_PollEvent(&event);
  176.   switch(event.type){
  177.     case SDL_KEYDOWN:
  178.       switch (event.key.keysym.sym){
  179.         case SDLK_v:
  180.           *vecteur = 0;
  181.           break;
  182.       }
  183.        break;
  184.   }
  185. }
  189. /*Procédure: Attend jusqu'à l'appuie sur une touche
  190.   Précondition: Avoir initialisé la SDL
  191. */
  192. void attendTouche(void)
  193. {
  194.   int continuer=1;
  195.   SDL_Event event;
  197.   while (continuer){
  198.         SDL_WaitEvent(&event);
  199.         switch(event.type){
  200.           case SDL_KEYDOWN:
  201.             continuer = 0;
  202.             break;
  203.         }
  204.   }
  205. }


 
evenement.h

Code :
  1. #ifndef EVENEMENT_H
  2. #define EVENEMENT_H
  3. #include "commun.h"
  7. /*Procédure: Permet à l'utilisateur d'initialiser les particules (position, vitesse et rayon)
  8.   Données: Tableau, et adresse de la surface contenant l'écran
  9.   EB: modification des cases du tableau aux lignes indiquées
  10.   Précondition: Avoir initialisé la SDL
  11. */
  12. void init(double point[][NBPART], SDL_Surface *ecran);
  15. /*Procédure: Affiche un vecteur vitesse depuis le centre d'un particule
  16.   Donnée: le tableau contenant les vitesses et la position et le n° de la colonne de la particule
  17.   EB: Auncun
  18.   Précondition: Avoir initialisé la SDL
  19. */
  20. void afficheUneVitesse(double point[][NBPART], int j);
  23. void calculeAcc(int indice, double point[][NBPART]);
  24. void eulerVit(int indice, double point[][NBPART]);
  25. void eulerPos(int indice, double point[][NBPART]);
  35. /*Procédure: Affiche les particuels avec leur vecteurs vitesse ou non
  36.   Données: tableau où sont stockés la position et le vecteur vitesse des particules,
  37.            booléen pour le cercle et le vecteur
  38.   EB: aucun
  39.   Préconditions: avoir initialisé la vitesse et la position des particules ainsi que la SDL.
  40. */
  41. void affichePoint(double point[][NBPART], int Vecteur);
  47. /*Procédure: vérifié si la touche echape est pressée ou si on a un évènement SDL_QUIT (clique sur la croix)
  48.              sans bloquer l'éxecution du programme
  49.   Données: Adresse de la varible de boucle et variable de l'évènement.
  50.   EB: mise à zéro de la variable si un des deux évènement est détecté.
  51.   Préconditions: avoir initialisé la SDL
  52. */
  53. void quitterOuEchap(int *continuer, SDL_Event event);
  55. void appuisSurV(int *vecteur, SDL_Event event);
  57. /*Procédure: Attend jusqu'à l'appuie sur une touche
  58.   Précondition: Avoir initialisé la SDL
  59. */
  60. void attendTouche(void);
  65. #endif


 
commun.h

Code :
  1. #ifndef COMMUN_H
  2. #define COMMUN_H
  4. #define COEF_FROTTEMENT 0
  5. #define g 9.81
  6. #define NBPART 1
  7. #define DT 0.1
  8. #define DELAI_MS 5
  9. #define DELAI_S 0.005
  12. enum
  13. {
  14.   POSX=0, POSY, VITX, VITY, ACCX, ACCY, MASSE, CONSTANTE_RAIDEUR, LONGUEUR_VIDE, COULEUR,
  17.   NB_PROP
  18. };
  21. #endif


 
 
Merci pour votre aide.

Message cité 1 fois
Reply

Marsh Posté le 19-01-2010 à 19:03:54   

Reply

Marsh Posté le 19-01-2010 à 19:19:00    

t'as bien ajouter tes .c à ta cible ?
 
et bon, compiler en ligne de commande, au debut ca forme :o

Message cité 1 fois
Reply

Marsh Posté le 19-01-2010 à 19:20:39    

Cpowa a écrit :

Code :
  1. void calculeAcc(int indice, double point[][NBPART])
  2. {
  3.   point[ACCX][indice]=(-1*point[CONSTANTE_RAIDEUR][indice]/point[MASSE][indice])*(sqrt((point[POSX][indice]-400)*(point[POSX][indice]-400)+(point[POSY][indice]-400)*(point[POSY][indice]-400))-point[LONGUEUR_VIDE][indice])*((point[POSX][indice]-400)/sqrt((point[POSX][indice]-400)*(point[POSX][indice]-400)+(point[POSY][indice]-400)*(point[POSY][indice]-400)))-(COEF_FROTTEMENT/point[MASSE][indice])*point[VITX][indice];
  4.   point[ACCY][indice]=g-(-1*point[CONSTANTE_RAIDEUR][indice]/point[MASSE][indice])*(sqrt((point[POSX][indice]-400)*(point[POSX][indice]-400)+(point[POSY][indice]-400)*(point[POSY][indice]-400))-point[LONGUEUR_VIDE][indice])*((point[POSY][indice]-400)/sqrt((point[POSX][indice]-400)*(point[POSX][indice]-400)+(point[POSY][indice]-400)*(point[POSY][indice]-400)))-(COEF_FROTTEMENT/point[MASSE][indice])*point[VITY][indice];
  6. }



WTF ? [:pingouino]  
 
 
tu es sur que tu compiles bien tous tes sources ? Parce que là, on dirait que tu buildes juste ton main avec SDL, mais que tu n'as pas inclus les.o de tes autres fichiers .c
 
Edit : grillé en beauté =o

Message cité 1 fois
Message édité par theshockwave le 19-01-2010 à 19:21:07

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

Marsh Posté le 19-01-2010 à 19:29:12    

Joel F a écrit :

t'as bien ajouter tes .c à ta cible ?
 
et bon, compiler en ligne de commande, au debut ca forme :o


 
 
je compilais en commande quand j'étais sous OpenSuSE
 
Tout mes fichiers sont bien ajoutés au projet.
 

theshockwave a écrit :


WTF ? [:pingouino]  


Oui je sais, c'est l'accélération d'un pendule-ressort, j'en ai chié pour écrire ça  :o  
 

theshockwave a écrit :


tu es sur que tu compiles bien tous tes sources ? Parce que là, on dirait que tu buildes juste ton main avec SDL, mais que tu n'as pas inclus les.o de tes autres fichiers .c
 
Edit : grillé en beauté =o


Oui, comme je l'ai dit.
 
 
 
 
 
 
Je précise que les 3/4 des sources proviennent d'un autre prog SDL que j'ai fait il y a un an et que j'ai réutilisé.
Et ce programme fonctionne parfaitement.
 
Mais comme par hasard les fonctions listées dans le log sont celles que j'ai modifiées/réécrites/crées.
Pourtant elles sont bonnes.


Message édité par Cpowa le 19-01-2010 à 19:30:08
Reply

Marsh Posté le 19-01-2010 à 19:31:53    

Oué, elle est tordue cette erreur.
 
Dans Evenement.c:init() tu as oublié une accolade fermante (certainement celle de la boucle for). Ce qui fait que toutes les fonctions déclarés sont locales à init() (extension de gcc, je suppose), ce qui fait que ça foire à l'édition des liens.
 
  [:tinostar] Et tu as une accolade en trop dans affichePoint().

Message cité 1 fois
Message édité par tpierron le 19-01-2010 à 19:33:25
Reply

Marsh Posté le 19-01-2010 à 19:37:14    

tpierron a écrit :

Oué, elle est tordue cette erreur.
 
Dans Evenement.c:init() tu as oublié une accolade fermante (certainement celle de la boucle for). Ce qui fait que toutes les fonctions déclarés sont locales à init() (extension de gcc, je suppose), ce qui fait que ça foire à l'édition des liens.
 
  [:tinostar] Et tu as une accolade en trop dans affichePoint().


Tu sais que je t'aime toi  :love:  :love:  :love:  :love:  :love:  :love:  :love:  :love:  :love:  :love:  :love:  :love:

Reply

Marsh Posté le 19-01-2010 à 19:44:38    

j'ai une autre question qui n'a rien à voir.
 
Vous savez comment on affiche la console avec un programme SDL ?
J'ai cherché partout mais j'ai pas trouvé.
J'en ai besoin pour passer des données au programme.
 
Quand je compile en "console application" j'ai bien la console qui s'affiche mais impossible d'afficher quoi que ce soit dedans avec des printf

Reply

Marsh Posté le 19-01-2010 à 20:09:04    

Mouais, faut voir ce que tu veux faire avec. Si c'est juste pour un peu de debug, normallement si tu passes par le wizard de code::blocks pour créer un projet SDL, en compilant en mode DEBUG, la console sera présente (et les lectures/écriture fonctionneront). En release, la console est désactivée.
 
J'ai la flemme de voir le détail, je pense qu'il y un module de démarrage custom. Cela dit, c'est juste pour le debug, car un fgets va te figer ta fenêtre SDL (notamment aucun refresh lorsque la fenêtre MS-DOS passera inévitablement au premier plan). Si tu as la flemme de faire une vraie interface (d'autant que c'est un peu la bidouille pour faire cohabiter comctl32 et SDL en même temps), passe par un fichier texte ou des paramètres en ligne de commande.

Message cité 1 fois
Message édité par tpierron le 19-01-2010 à 20:11:32
Reply

Marsh Posté le 19-01-2010 à 20:26:36    

tpierron a écrit :

Si tu as la flemme de faire une vraie interface (d'autant que c'est un peu la bidouille pour faire cohabiter comctl32 et SDL en même temps), passe par un fichier texte ou des paramètres en ligne de commande.


C'est plus par manque de temps que la flèmme.
J'aimerais bien les passer en ligne de commande, mais comment je fais ?  :D

Reply

Marsh Posté le 19-01-2010 à 20:39:03    

int main(int argc, const char** argv) :E

Message cité 1 fois
Message édité par Joel F le 19-01-2010 à 20:39:17
Reply

Marsh Posté le 19-01-2010 à 20:39:03   

Reply

Marsh Posté le 19-01-2010 à 21:12:54    

Joel F a écrit :

int main(int argc, const char** argv) :E


 
il aime pas, il me met 4erreurs

Code :
  1. taire\Bureau\pendule\main.c|11|error: conflicting types for 'SDL_main'|
  2. C:\Program Files\CodeBlocks\SDL-1.2.14\include\SDL\SDL_main.h|57|error: previous declaration of 'SDL_main' was here|
  3. taire\Bureau\pendule\main.c|11|error: conflicting types for 'SDL_main'|
  4. C:\Program Files\CodeBlocks\SDL-1.2.14\include\SDL\SDL_main.h|57|error: previous declaration of 'SDL_main' was here|
  5. ||=== Build finished: 4 errors, 0 warnings ===|


Et je suppose que c'est pas portable ?

Reply

Marsh Posté le 19-01-2010 à 21:55:33    

non mais attend, t'as deja ouvert un livre de C ou bien ?
Regarde le code que tu as posté, tu as DEJA le bon prototype.
RTFM là quoi [:pingouino]

Message cité 1 fois
Reply

Marsh Posté le 19-01-2010 à 21:58:15    

Euh, il ne faut pas mettre de "const" dans le prototype de main.
 
La première version de ton main() était correcte. Pour passer les arguments depuis Code::Blocks utilise le menu "Project => Set program's argument".

Message cité 2 fois
Reply

Marsh Posté le 19-01-2010 à 22:31:49    

Joel F a écrit :

non mais attend, t'as deja ouvert un livre de C ou bien ?


oui y a longtemps  :o  

Joel F a écrit :


Regarde le code que tu as posté, tu as DEJA le bon prototype.
RTFM là quoi [:pingouino]


Oui mais je captais pas pourquoi tu me filais un prototype foireux  
 

tpierron a écrit :

Euh, il ne faut pas mettre de "const" dans le prototype de main.
 
La première version de ton main() était correcte. Pour passer les arguments depuis Code::Blocks utilise le menu "Project => Set program's argument".


merci  :jap:  

Reply

Marsh Posté le 19-01-2010 à 22:50:49    

tpierron a écrit :

Euh, il ne faut pas mettre de "const" dans le prototype de main.


je me  gourres-je avec C++ ?


Message édité par Joel F le 19-01-2010 à 22:50:59
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed