SDL2, Code::block, gestion evenement, creation de surface

Résolu
poparnassus Messages postés 462 Statut Membre -  
poparnassus Messages postés 462 Statut Membre -
Bonjour,

Objectif : Piloter un robot.

Suite a mon post precedent, je repost un nouveau l"autre page commencé a aetre charger en code

Resumer de ce que je faire:
1) Recuperer des evenements clavier, joystick : Ca c'est OK ca marche.

2) Simuler la manette via un dessin, afficher un rectangle contenant 2 cercle a chaque coter avec des points des point dans chaque cercle qui representeront les cordonnees X,Y de mes joysticks JG(X,Y) et JD(X,Y).
Et au milieu du rectangle, entre les 2 cercle un carrer de 4 case de couleur Bleu, verte, rouge et orange ( reprensentation des boutons de la manette donc pour les variables BOUTTON_A, BOUTTON_B, BOUTTON_Y, BOUTTON_X.
C'est la que j'ai besoin d'un coup de main ...

3) Et ensuite envoyer les donnees du joystick sur le reseau, sur raspberry PI B+

J'ai trouver quelque code pour m'inspirer mais des que mes fonctions sont en relation avec des structure ca marche pas, j'ai pas tout piger, j'ai du mal a aplliquer la methode.

ex:
https://alexandre-laurent.developpez.com/tutoriels/sdl-2/afficher-sprites-sdl-2/#LIII-A

https://fc.isima.fr/~loic/unixc/tpc-sdlflood.php

https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/doku.php/stu:progc:sdl

https://meruvia.fr/index.php/big-tuto-sdl-2-nouveau/147-big-tuto-sdl-2-chapitre-4-ouvrons-notre-1ere-fenetre-sur-le-monde
LE CODE:

main.c

#include "fonction.h"



int main(int argc, char** argv)
{
    //Creation des structures
    Input input;
    Affichage affichage;

    //Init de SDL_VIDEO , SDL_JOYSTICK , SDL_TTF et de la structure affichage
    initialisation("Programe WILD THUMPER : Station de pilotage",&affichage);

    //initialisation des structures
    initialisationInput(&input); //init input + evenement joystick

    //int tableau[12]= {input->JGX,input->JGY,input->JDX,input->JDY,input->BOUTTON_A,input->BOUTTON_B,input->BOUTTON_Y,input->BOUTTON_X,input->BOUTTON_LB,input->BOUTTON_RB,input->BOUTTON_START,input->BOUTTON_BACK};
    int tableau[12]= {input.JGX,input.JGY,input.JDX,input.JDY,input.BOUTTON_A,input.BOUTTON_B,input.BOUTTON_Y,input.BOUTTON_X,input.BOUTTON_LB,input.BOUTTON_RB,input.BOUTTON_START,input.BOUTTON_BACK};

if (affichage.screen)
{
    //affichage(&affichage);

    while (!input.quitter)
    {
        SDL_Delay(1);

        updateEvent(&input);

        {//Afficher valeaur en utilisant la structure input

        printf("Mode de pilotage  %d \n\n",input.mode_pilotage);

        printf("JOYSTICK GAUCHE: X= %d ,Y= %d \n\n",input.JGX,input.JGY);
        printf("JOYSTICK DROITE: X= %d ,Y= %d \n\n",input.JDX,input.JDY);

        printf("BOUTTON A= %d \n",input.BOUTTON_A);
        printf("BOUTTON B= %d \n",input.BOUTTON_B);
        printf("BOUTTON Y= %d \n",input.BOUTTON_Y);
        printf("BOUTTON X= %d \n",input.BOUTTON_X);

        }

        if (input.mode_pilotage !=0)
        {
            printf("Envoie de données sur le reseau : OK\n\n");

            //Envoy des info sur le reseau
        }
        else
        {
            printf("Choisissez le mode de pilotage avec RL ou RB \n\n ");
        }



        system("cls");
    }
}

    //Efface tous ce qui est liée au fonction affichage
    SDL_DestroyTexture(affichage.Texture); // Libération de la mémoire associée à la texture
    SDL_FreeSurface(affichage.Fondecran); // Libération de la ressource occupée par le sprite
    SDL_DestroyRenderer(affichage.ren); // Libération de la mémoire du SDL_Renderer
    SDL_DestroyWindow(affichage.screen);

    SDL_JoystickClose(input.joystick);
    SDL_Quit();

    return 0;
}



fonction.h
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <SDL2/SDL.h>
#include <SDL2/SDL_ttf.h>

//Structure qui gere les evenements joystick, clavier
typedef struct Input Input;
struct Input
{
    SDL_Joystick* joystick;
    int quitter ;
    int quittermode ;

    //Variable Joystick
    int JGX ; //1
    int JGY ; //2
    int JDX ; //3
    int JDY ; //4
    int BOUTTON_A; //5- 0 Pour Boutton Relacher
    int BOUTTON_B ;//6
    int BOUTTON_Y ;//7
    int BOUTTON_X ;//8
    int BOUTTON_LB ; //9 boutton Gauche
    int BOUTTON_RB ; //10 boutton droite
    int BOUTTON_START ;//11
    int BOUTTON_BACK ; //12
    //Zone morte
    int DEADZONE_N ;
    int DEADZONE_P;

    //Mode de pilotage
    int mode_pilotage;


};

//Structure qui gere l'affichage des images.

typedef struct Affichage Affichage;
struct Affichage
{
    //Fenetre
    int WIDTH, HEIGHT;

    SDL_Window *screen; //Fenetre principale
    SDL_Renderer *ren ;

    SDL_Surface *Fondecran; //Chargement de l'image
    //SDL_Surface *icone;
    SDL_Texture *Texture;
    SDL_Rect dest; //definition de l'endroit sur la fenetre où on blitz l'image

    //SDL2_TTF
    TTF_Font* font;

};

//Declaration des fonctions

void initialisation(char *titre,Affichage *affichage);

void initialisationInput(Input *input);

void updateEvent(Input *input);

void affichage(Affichage *affichage);



fonction.c
#include "fonction.h"

void initialisation(char *titre,Affichage *affichage)
{
    if (SDL_Init( SDL_INIT_VIDEO |SDL_INIT_JOYSTICK) != 0)
    {
        fprintf(stderr,"Impossible de charger la SDL. SDL_ERROR = %s \n", SDL_GetError());
        EXIT_FAILURE;
    }
    //Initialisation TTF Pour ecrire du texte dans la fenetre SDL
    if(TTF_Init() != 0)
    {
        fprintf(stderr,"Impossible de charger la SDL2_TTF_Init: %s\n", TTF_GetError());
        EXIT_FAILURE;
    }
    else
    {
        //on ouvre une police
        //affichage->font = TTF_OpenFont("CaslonRoman.ttf", 16);
    }

    /* A partir de là, je souhaite crée ma fenetre, afficher une image de fond pour pouvoir dessiner mes surfaces */


    SDL_Window *screen = NULL;
    SDL_Renderer *ren = NULL;

    //Dimension Fenetre principale
    affichage->WIDTH = 1000, affichage->HEIGHT = 480 ;

    //Creation de la fenetre
    affichage->screen = SDL_CreateWindow(titre,SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,affichage->WIDTH,affichage->HEIGHT,SDL_WINDOW_SHOWN);
    //Creation du renderer
    affichage->ren = SDL_CreateRenderer(affichage->screen,-1,SDL_RENDERER_PRESENTVSYNC);

    //chargement de l'image de fond
    affichage->Fondecran = SDL_LoadBMP("6wd.bmp");






}

void affichage(Affichage *affichage)
{
    /* Cette fonction aura pour objectif d'afficher un rectangle contenant 2 cercle a chaque coter pour simuler les joystick avec des points
     et un point dans chaque cercle qui representeront les cordonnees X,Y de mes joysticks JG(X,Y) et JD(X,Y).
     Et au milieu du rectangle, entre les 2 cercle un carrer de 4 case de couleur Bleu, verte, rouge et orange ( reprensentation des boutons
    de la manette donc pour les variables BOUTTON_A, BOUTTON_B, BOUTTON_Y, BOUTTON_X.
    Ce qui suit est un test, J4ARRIVE MEME PAS A AFFICHER UNE IMAGE LOL
     */

    affichage->dest.x = 0;
    affichage->dest.y = 0;

    SDL_SetColorKey(affichage->Fondecran, SDL_TRUE, SDL_MapRGB(affichage->Fondecran->format, 255, 0, 255));

    affichage->Texture= SDL_CreateTextureFromSurface(affichage->ren, affichage->Fondecran);

    affichage->dest = { affichage->WIDTH/2 - affichage->Fondecran->w/2, affichage->HEIGHT/2 - affichage->Fondecran->h/2, affichage.Fondecran->w, affichage.Fondecran->h  };

    SDL_RenderCopy(affichage->ren,affichage->Texture,NULL,affichage->dest); // Copie du sprite grâce au SDL_Renderer

    SDL_RenderPresent(affichage->ren);

}


void initialisationInput(Input *input)
{
    SDL_JoystickEventState(SDL_ENABLE);

    //Verifie si un joystixk est connecter
    if (SDL_NumJoysticks() < 1)
    {
        printf("Pas de joystick connecter. \n");
        EXIT_FAILURE;
    }

    input->joystick = SDL_JoystickOpen(0);
    input->quitter = 0;
    input->quittermode = 0;

    input->JGX = 0; //position tableau = 0
    input->JGY = 0; //position tableau = 1
    input->JDX = 0; //position tableau = 2
    input->JDY = 0; //position tableau = 3
    input->BOUTTON_A = 0; //position tableau = 4 - 0 Pour Boutton Relacher
    input->BOUTTON_B = 0;//position tableau = 5
    input->BOUTTON_Y = 0;//position tableau = 6
    input->BOUTTON_X = 0;//position tableau = 7
    input->BOUTTON_LB = 0; //position tableau = 8 boutton Gauche
    input->BOUTTON_RB = 0; //position tableau = 9 boutton droite
    input->BOUTTON_START = 0;//position tableau = 10
    input->BOUTTON_BACK = 0; //position tableau = 11
    //Zone morte
    input->DEADZONE_P = 8000;
    input->DEADZONE_N = -8000;

    //Mode de pilotage
    input->mode_pilotage = 0;
}



void updateEvent(Input *input)
{
    static SDL_Event e;

        while (SDL_PollEvent(&e))
        {
            if (SDL_NumJoysticks() < 1)
            {
                input->quitter = 1;
            }
            if (e.type == SDL_KEYDOWN)
            {
                if (e.key.keysym.sym == SDLK_ESCAPE)
                {
                    input->quitter = 1;
                }
            }
            if (e.type == SDL_WINDOWEVENT)
            {
                if (e.window.event == SDL_WINDOWEVENT_CLOSE)
                {
                    input->quitter = 1;
                }
            }

            if (e.type == SDL_JOYAXISMOTION)  //ICI on gere les axes du joystique donc JGX, JGY, JDX, JDY
            {
                //Si le chapeau Gauche a détecté un mouvement
                if (e.jaxis.which == 0)
                {
                //Si le mouvement a eu lieu sur l'axe des X
                    if (e.jaxis.axis == 0)
                    {
                        //Si l'axe des X est neutre ou à l'intérieur de la "dead zone", je recupere J0X
                        if ((e.jaxis.value > input->DEADZONE_N) && (e.jaxis.value < input->DEADZONE_P))
                        {
                            input->JGX = 0;
                        }
                        else
                        {
                            if (e.jaxis.value < input->DEADZONE_N)
                            {
                                input->JGX = e.jaxis.value;
                            }
                            else if (e.jaxis.value > input->DEADZONE_P)
                            {
                                input->JGX = e.jaxis.value;
                            }
                        }
                    }
                    //Si le mouvement a eu lieu sur l'axe des Y, je recupere J0Y
                    else if (e.jaxis.axis == 1)
                    {
                        //Si l'axe des Y est neutre ou à l'intérieur de la "dead zone"
                        if ((e.jaxis.value > input->DEADZONE_N) && (e.jaxis.value < input->DEADZONE_P))
                        {
                            input->JGY = 0;
                        }
                        else
                        {
                            if (e.jaxis.value < input->DEADZONE_N)
                            {
                                input->JGY = e.jaxis.value;
                            }
                            else if (e.jaxis.value > input->DEADZONE_P)
                            {
                                input->JGY = e.jaxis.value;
                            }
                        }
                    }
                    //Si le mouvement a eu lieu sur l'axe des X
                    if (e.jaxis.axis == 2)
                    {
                        //Si l'axe des X est neutre ou à l'intérieur de la "dead zone", je recupere J0X
                        if ((e.jaxis.value > input->DEADZONE_N) && (e.jaxis.value < input->DEADZONE_P))
                        {
                            input->JDX = 0;
                        }
                        else
                        {
                            if (e.jaxis.value < input->DEADZONE_N)
                            {
                                input->JDX = e.jaxis.value;
                            }
                            else if (e.jaxis.value > input->DEADZONE_P)
                            {
                                input->JDX = e.jaxis.value;
                            }
                        }
                    }
                    //Si le mouvement a eu lieu sur l'axe des Y, je recupere J0Y
                    else if (e.jaxis.axis == 3)
                    {
                        //Si l'axe des Y est neutre ou à l'intérieur de la "dead zone"
                        if ((e.jaxis.value > input->DEADZONE_N) && (e.jaxis.value < input->DEADZONE_P))
                        {
                            input->JDY = 0;
                        }
                        else
                        {
                            if (e.jaxis.value < input->DEADZONE_N)
                            {
                                input->JDY = e.jaxis.value;
                            }
                            else if (e.jaxis.value > input->DEADZONE_P)
                            {
                                input->JDY = e.jaxis.value;
                            }
                        }
                    }
                }
            }

            if (e.type == SDL_JOYBUTTONDOWN) //ICI on gere les bouttons BOUTTON APPUYER
            {
                if (e.jbutton.button == 10)
                {
                    input->BOUTTON_A = 1;
                }
                else if (e.jbutton.button == 11)
                {
                    input->BOUTTON_B = 1;
                }
                else if (e.jbutton.button == 12)
                {
                    input->BOUTTON_X = 1;
                }
                else if (e.jbutton.button == 13)
                {
                    input->BOUTTON_Y = 1;
                }
                else if (e.jbutton.button == 8)
                {
                    input->BOUTTON_LB = 1;
                    input->mode_pilotage =1;
                    //tableau[8]= 1;
                }
                else if (e.jbutton.button == 9)
                {
                    input->BOUTTON_RB =1;
                     input->mode_pilotage =2;
                    //tableau[9]= 1;
                }
                else if ( e.jbutton.button == 4)
                {
                    input->BOUTTON_START=1;
                }
                else if (e.jbutton.button == 5)
                {
                    input->BOUTTON_BACK = 1;
                    input->quitter = 1;
                }
            }
            else if (e.type == SDL_JOYBUTTONUP)
            {
                 if (e.jbutton.button == 10)
                {
                    input->BOUTTON_A = 0;
                }
                else if (e.jbutton.button == 11)
                {
                    input->BOUTTON_B = 0;
                }
                else if (e.jbutton.button == 12)
                {
                    input->BOUTTON_X = 0;
                }
                else if (e.jbutton.button == 13)
                {
                    input->BOUTTON_Y = 0;
                }
                else if (e.jbutton.button == 8)
                {
                }
                else if (e.jbutton.button == 9)
                {
                }
                else if ( e.jbutton.button == 4)
                {
                    input->BOUTTON_START=0;
                }
                else if (e.jbutton.button == 5)
                {
                    input->BOUTTON_BACK = 0;
                }
            }
        }
}




LOG COMPILATEUR:
||=== Build: Debug in 6wd_SDL2_test (compiler: GNU GCC Compiler) ===|
C:\Users\Nico\Desktop\Projet C\6wd_SDL2_test\fonction.c||In function 'initialisation':|
C:\Users\Nico\Desktop\Projet C\6wd_SDL2_test\fonction.c|26|warning: unused variable 'ren' [-Wunused-variable]|
C:\Users\Nico\Desktop\Projet C\6wd_SDL2_test\fonction.c|25|warning: unused variable 'screen' [-Wunused-variable]|
C:\Users\Nico\Desktop\Projet C\6wd_SDL2_test\fonction.c||In function 'affichage':|
C:\Users\Nico\Desktop\Projet C\6wd_SDL2_test\fonction.c|62|error: expected expression before '{' token|
C:\Users\Nico\Desktop\Projet C\6wd_SDL2_test\fonction.c|64|error: incompatible type for argument 4 of 'SDL_RenderCopy'|
..\..\..\..\..\Program Files (x86)\CodeBlocks\SDL2-2.0.0\i686-w64-mingw32\include\SDL2\SDL_render.h|745|note: expected 'const struct SDL_Rect *' but argument is of type 'SDL_Rect'|
||=== Build failed: 2 error(s), 2 warning(s) (0 minute(s), 0 second(s)) ===|

5 réponses

  1. [Dal] Messages postés 6122 Date d'inscription   Statut Contributeur Dernière intervention   1 108
     
    Salut poparnassus,

    Les numéros de lignes signalés par le compilateur ne correspondent pas aux numéros de ligne que tu postes.

    En outre, ton programme est long et sans doutes 90% est non pertinent par rapport à ta question, qui, par ailleurs, n'est pas claire.

    Fait l'effort de faire un programme de 10 lignes qui illustre ton problème, et de formuler clairement ta question.

    C'est la base du débogage que de circonscrire ton problème.

    Probablement, en faisant cela, tu verras où se trouve la cause des erreurs, et tu n'auras même pas besoin de poser une question ici.

    Dal
    1
    1. poparnassus Messages postés 462 Statut Membre 31
       
      C'est vraiment au niveau des poinnteur que c'est pas clair sans pointeur ca marche, mais des que j'ajoute une structure ca marche plus.
      Quelque chose que je fais mal mais je ne sais pas quoi...

      Ma structure affichage
      typedef struct Affichage Affichage;
      struct Affichage
      {
          //Fenetre
          int WIDTH, HEIGHT;
      
          int rax ;
          int ray ;
          int raw;
          int rah ;
      
          SDL_Texture *ArrierePlan;
      
          SDL_Rect *rectangle1;
          SDL_Rect *rectangleA;
          SDL_Rect *rectangleB;
          SDL_Rect *rectangleX;
          SDL_Rect *rectangleY;
      
      
      };
      
      


      Ma fonction initialisation affichage
      void intialisationAffichage(Affichage *affichage)
      {
          affichage->rectangle1->x = 0;
          affichage->rectangle1->y = 0;
          affichage->rectangle1->w = 0;
          affichage->rectangle1->h = 0;
      
          affichage->rax = 0;
          affichage->ray = 0;
          affichage->raw = 0;
          affichage->rah = 0;
      
          affichage->rectangleA->x = 0;
          affichage->rectangleA->y = 0;
          affichage->rectangleA->w = 0;
          affichage->rectangleA->h = 0;
      
          affichage->rectangleB->x = 0;
          affichage->rectangleB->y = 0;
          affichage->rectangleB->w = 0;
          affichage->rectangleB->h = 0;
      
          affichage->rectangleY->x = 0;
          affichage->rectangleY->y = 0;
          affichage->rectangleY->w = 0;
          affichage->rectangleY->h = 0;
      
          affichage->rectangleX->x = 0;
          affichage->rectangleX->y = 0;
          affichage->rectangleX->w = 0;
          affichage->rectangleX->h = 0;
      
      }
      


      void ArrierePlan(char *titre,Affichage *affichage)
      {
          affichage->ArrierePlan = NULL;
          //affichage->Texture = NULL;
      
          //Creation de la fenetre
          screen = SDL_CreateWindow(titre,SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,WINDOW_W,WINDOW_H,SDL_WINDOW_SHOWN);
          //Creation du renderer
          renderer = SDL_CreateRenderer(screen,-1,SDL_RENDERER_ACCELERATED);
      
           if (screen == NULL || renderer == NULL)
          {
              printf("Impossible d'initialiser le mode ecran %s ,\n", SDL_GetError());
          }
      
          SDL_SetRenderDrawColor(renderer, 255, 0, 0, 0);
          SDL_RenderClear(renderer);
      
          //chargement de l'image de fond
         // affichage->ArrierePlan = SDL_LoadBMP("6wd.bmp");
      
          //SDL_CreateTextureFromSurface(renderer, affichage->ArrierePlan);
      
          int r1w =WINDOW_W  , r1h = WINDOW_H/4;
      
      
          SDL_Rect *rectangle1 ;
          affichage->rectangle1->x = 20;
          affichage->rectangle1->y = 20;
          affichage->rectangle1->w = r1w - (affichage->rectangle1->x*2);
          affichage->rectangle1->h = r1h - (affichage->rectangle1->y*2);
          SDL_SetRenderDrawColor(renderer,255,255,255,255); // blanc
          SDL_RenderFillRect(renderer,affichage->rectangle1);
      
          affichage->rax = (affichage->rectangle1->x)+((affichage->rectangle1->w/2)-(((affichage->rectangle1->h) - (affichage->rectangle1->x))/2));
          affichage->ray = (affichage->rectangle1->y)+((affichage->rectangle1->h /2)-(((affichage->rectangle1->h) - (affichage->rectangle1->x)) /2));
          affichage->raw = affichage->rectangle1->h-affichage->rectangle1->x;
          affichage->rah = affichage->rectangle1->h-affichage->rectangle1->x;
      
          //SDL_Rect *rectangleA ;
          affichage->rectangleA->x = affichage->rax;
          affichage->rectangleA->y = affichage->ray;
          affichage->rectangleA->w = affichage->raw/2;
          affichage->rectangleA->h =affichage->rah /2;
          SDL_SetRenderDrawColor(renderer,0,255,64,0); //VERT
          SDL_RenderFillRect(renderer, affichage->rectangleA);
      
          //SDL_Rect *rectangleB ;
          affichage->rectangleB->x = affichage->rax + (affichage->raw/2);
          affichage->rectangleB->y = affichage->ray;
          affichage->rectangleB->w = affichage->raw/2;
          affichage->rectangleB->h =affichage->rah /2;
          SDL_SetRenderDrawColor(renderer,255,128,128,0);
          SDL_RenderFillRect(renderer, affichage->rectangleB);
      
          //SDL_Rect *rectangleY ;
          affichage->rectangleY->x = affichage->rax ;
          affichage->rectangleY->y = affichage->ray+ (affichage->raw/2);
          affichage->rectangleY->w = affichage->raw/2;
          affichage->rectangleY->h =affichage->rah /2;
          SDL_SetRenderDrawColor(renderer,255,128,0,0); //ORANGE
          SDL_RenderFillRect(renderer, affichage->rectangleY);
      
          //SDL_Rect *rectangleX ;
          affichage->rectangleX->x = affichage->rax + (affichage->raw/2);
          affichage->rectangleX->y = affichage->ray+ (affichage->raw/2);
          affichage->rectangleX->w = affichage->raw/2;
          affichage->rectangleX->h =affichage->rah /2;
          SDL_SetRenderDrawColor(renderer,0,0,255,0); //BLEU
          SDL_RenderFillRect(renderer, affichage->rectangleX);
      
          SDL_RenderPresent(renderer);
      
      
      /* Cette partie là fonctionne , mais sans pointeur or j'ai besoine de pointeur
            SDL_Rect rectangle1 ;
          affichage->rectangle1->x = 20;
          rectangle1.y = 20;
          rectangle1.w = r1w - (rectangle1.x*2);
          rectangle1.h = r1h - (rectangle1.y*2);
          SDL_SetRenderDrawColor(renderer,255,255,255,255); // blanc
          SDL_RenderFillRect(renderer, &rectangle1);
      
          int rax = (rectangle1.x)+((rectangle1.w/2)-(((rectangle1.h) - (rectangle1.x))/2)),
          ray = (rectangle1.y)+((rectangle1.h /2)-(((rectangle1.h) - (rectangle1.x)) /2)),
          raw = rectangle1.h-rectangle1.x,
          rah = rectangle1.h-rectangle1.x;
      
          SDL_Rect rectangleA ;
          rectangleA.x = rax;
          rectangleA.y = ray;
          rectangleA.w = raw/2;
          rectangleA.h =rah /2;
          SDL_SetRenderDrawColor(renderer,0,255,64,0); //VERT
          SDL_RenderFillRect(renderer, &rectangleA);
      
          SDL_Rect rectangleB ;
          rectangleB.x = rax + (raw/2);
          rectangleB.y = ray;
          rectangleB.w = raw/2;
          rectangleB.h =rah /2;
          SDL_SetRenderDrawColor(renderer,255,128,128,0);
          SDL_RenderFillRect(renderer, &rectangleB);
      
          SDL_Rect rectangleY ;
          rectangleY.x = rax ;
          rectangleY.y = ray+ (raw/2);
          rectangleY.w = raw/2;
          rectangleY.h =rah /2;
          SDL_SetRenderDrawColor(renderer,255,128,0,0); //ORANGE
          SDL_RenderFillRect(renderer, &rectangleY);
      
          SDL_Rect rectangleX ;
          rectangleX.x = rax + (raw/2);
          rectangleX.y = ray+ (raw/2);
          rectangleX.w = raw/2;
          rectangleX.h =rah /2;
          SDL_SetRenderDrawColor(renderer,0,0,255,0); //BLEU
          SDL_RenderFillRect(renderer, &rectangleX);
      
          SDL_RenderPresent(renderer);
      */
      }
      



      |warning: unused variable 'rectangle1' [-Wunused-variable]|

      J'ai la meme chose pour toute mes rectangle1 , A, B, X, Y
      0
    2. [Dal] Messages postés 6122 Date d'inscription   Statut Contributeur Dernière intervention   1 108
       
      ca marche plus

      c'est à dire ?

      bon, on va passer en mode boule de cristal...

      Je vois qu'à l'appel de la fonction intialisationAffichage(), tu passes en argument un pointeur sur Affichage, puisque ton prototype est
      void intialisationAffichage(Affichage *affichage)


      Question : lors de l'appel de cette fonction, est-ce que tu passes un pointeur sur une zone mémoire que tu as allouée, d'une façon ou d'une autre ?


      Dal
      0
    3. poparnassus Messages postés 462 Statut Membre 31
       
      Le compilateur me dit que mes variables rectangle1 A B X Y ne sont pas utiliser, et non je ne passe aucun pointeur en zone memoire, dois je le faire ? avec malloc() ?
      0
    4. poparnassus Messages postés 462 Statut Membre 31
       
      Bon j'ai declarer mes SDL_Rect rectangle1 A B X Y en variable globale sans utilisé de structure et la ca marche.
      Mais je ne sais toujours pas comment le faire avec des pointeurs!
      0
    5. [Dal] Messages postés 6122 Date d'inscription   Statut Contributeur Dernière intervention   1 108
       
      En C, lorsque tu utilises des pointeurs, ces pointeurs doivent pointer vers une zone mémoire allouée au pointeur. La simple déclaration du pointeur ne le fait pas. Il faut allouer la quantité de mémoire suffisante avec malloc() et libérer la mémoire lorsqu'on n'en a plus besoin avec free().

      Comme tu veux un pointeur sur cette structure, il faut allouer la mémoire correspondant à la taille de la struct.

      Comme cette struc comporte elle-même des pointeurs, il faudra les faire pointer vers un espace mémoire.

      Pour ArrierePlan, j'imagine que c'est SDL_CreateTexture() qui allouera la mémoire et retournera un pointeur sur SDL_Texture.

      Pour les pointeurs sur SDL_Rect, c'est à toi d'allouer la mémoire.

      Voilà un exemple limité, qui je l'espère t'éclairera, utilisant ta structure Affichage.

      #include <SDL2/SDL.h>
        
        struct Affichage
        {
            //Fenetre
            int WIDTH, HEIGHT;
      
            int rax ;
            int ray ;
            int raw;
            int rah;
      
            SDL_Texture *ArrierePlan;
      
            SDL_Rect *rectangle1;
            SDL_Rect *rectangleA;
            SDL_Rect *rectangleB;
            SDL_Rect *rectangleX;
            SDL_Rect *rectangleY;
        };
        typedef struct Affichage Affichage;
        
        
        int main(int argc, char** argv)
        {
            Affichage * aff;
        
            aff = (Affichage *)malloc(sizeof (Affichage));
        
            /* maintenant, on peut initialiser WIDTH, HEIGHT, rax, etc. */
            aff->WIDTH = 1000;
            aff->HEIGHT = 480;
            // suite ...
        
            /* affecter à ArrierePlan la résultat d'un SDL_CreateTexture */
            aff->ArrierePlan = SDL_CreateTexture( /* TODO */ );
        
            /* allouer la mémoire pour les rectangles */
            aff->rectangle1 = (SDL_Rect *)malloc(sizeof (SDL_Rect));
            aff->rectangleA = (SDL_Rect *)malloc(sizeof (SDL_Rect));
            aff->rectangleB = (SDL_Rect *)malloc(sizeof (SDL_Rect));
            aff->rectangleX = (SDL_Rect *)malloc(sizeof (SDL_Rect));
            aff->rectangleY = (SDL_Rect *)malloc(sizeof (SDL_Rect));
        
            /* faire des choses merveilleuses */
        
            /* quand on a terminé, libérer les ressources SDL, etc. */
            // TODO ...
            /* libérer la mémoire pour les rectangles */
            free(aff->rectangle1);
            free(aff->rectangleA);
            free(aff->rectangleB);
            free(aff->rectangleX);
            free(aff->rectangleY);
            /* libérer la mémoire pointée par aff */
            free(aff);
        } 


      Dal
      0
  2. [Dal] Messages postés 6122 Date d'inscription   Statut Contributeur Dernière intervention   1 108
     
    Salut poparnassus,

    Voilà une illustration basée sur ton code ci-dessus.

    #include <stdio.h>                 
    #include <SDL2/SDL.h>
    
    #define WINDOW_W 800
    #define WINDOW_H 800
    
    /* on crée un type struct permettant de stocker les variables utiles
     * à l'affichage SDL qu'on va pouvoir passer aux fonctions
     * éliminant ainsi la nécessité de créer des variables
     * globales */
    struct wt_SDL {
        SDL_Window *screen;
        SDL_Renderer *renderer;
        
        SDL_Rect rectangle1;
    };
    typedef struct wt_SDL wt_SDL;
    
    void RAZ_wt_SDL(wt_SDL *wt_SDL);
    void set_wt_SDL(const char *titre, wt_SDL *wt_SDL);
    void cleanup(wt_SDL *wt_SDL);
    
    void RAZ_wt_SDL(wt_SDL *wt_SDL)
    {   
        /* mise à zéro de la struct SDL_Rect */
        wt_SDL->rectangle1.x = 0;
        wt_SDL->rectangle1.y = 0;
        wt_SDL->rectangle1.w = 0;
        wt_SDL->rectangle1.h = 0;
    }
    
    void set_wt_SDL(const char *titre, wt_SDL *wt_SDL)
    {   
        /* Creation de la fenetre */
        wt_SDL->screen = SDL_CreateWindow(titre,SDL_WINDOWPOS_CENTERED,
                SDL_WINDOWPOS_CENTERED,WINDOW_W,WINDOW_H,SDL_WINDOW_SHOWN);
        /* Creation du renderer */
        wt_SDL->renderer = SDL_CreateRenderer(wt_SDL->screen,
                -1, SDL_RENDERER_ACCELERATED);
        if (wt_SDL->screen == NULL || wt_SDL->renderer == NULL) {
            printf("Impossible d'initialiser le mode ecran %s ,\n",
                    SDL_GetError());
        } else {   
            /* noir */
            SDL_SetRenderDrawColor(wt_SDL->renderer, 0, 0, 0,
                    SDL_ALPHA_OPAQUE);
            SDL_RenderClear(wt_SDL->renderer);
            wt_SDL->rectangle1.x = 20;
            wt_SDL->rectangle1.y = 20;
            wt_SDL->rectangle1.w = WINDOW_W - (wt_SDL->rectangle1.x*2);
            wt_SDL->rectangle1.h =  WINDOW_H/4;
            /* blanc */
            SDL_SetRenderDrawColor(wt_SDL->renderer, 255, 255, 255,
                    SDL_ALPHA_OPAQUE);
            SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangle1);
    
            SDL_RenderPresent(wt_SDL->renderer);
        }
    }
    
    void cleanup(wt_SDL *wt_SDL)
    {
        SDL_DestroyRenderer(wt_SDL->renderer);
        SDL_DestroyWindow(wt_SDL->screen);
        SDL_Quit();
    }
    
    int main(int argc, char** argv)
    {
        /* La création de la struct alloue la mémoire nécessaire
         * aux variables qu'elle contient */
        wt_SDL wt_SDL;
    
        /* pour la suite, on passe un pointeur sur la struct
         * pour faire un passage des paramètres par référence
         * et non par copie des données */
    
        /* Remise à zéro */
        RAZ_wt_SDL(&wt_SDL);
    
        /* Affichage de l'arriere plan */
        set_wt_SDL(" Programme Wild Thumper: Station de pilotage ",
                &wt_SDL);
    
        getchar();
    
        cleanup(&wt_SDL);
    
        return 0;
    }


    Dal
    1
    1. poparnassus Messages postés 462 Statut Membre 31
       
      Honetement, MILLE MERCI !! Grace à toi J'ai trouver pourquoi ca marcher pas, en faite je mettai un pointeur de cette façon
      SDL_Rect * rectangle1;
      et lorsque j'initialiser
       mastructure->rectangle1->x = 0 ;

      et quand je l'utilisai dans une fonction je placer une fleche "->" et non un (1) point
                  wt_SDL->rectangle1->x = 20;
                  wt_SDL->rectangle1->y = 20;
                  wt_SDL->rectangle1->w = WINDOW_W - (wt_SDL->rectangle1->x*2);
                  wt_SDL->rectangle1->h =  WINDOW_H/4;
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,0,0,0); // blanc
                  SDL_RenderFillRect(wt_SDL->renderer,wt_SDL->rectangle1);
      

      du coup ca marcher pas,
      (1) Du coup on met un point pour acceder a la structure d'une fonction qui n'est pas pointer, donc en faite on accede directement a sa valeur et non son adresse memoire.

      Mais j'ai du mal a comprendre pourquoi un pointeur sur SDL_Rect ne fonctionne pas, ou alors je l'ai mal utiliser.
      0
    2. poparnassus Messages postés 462 Statut Membre 31
       
      Par contre ligne 89, c'est quoi l'utilité de
      getchar();
      0
    3. poparnassus Messages postés 462 Statut Membre 31
       
      Un Petit Screen shot du progr !

      https://imgur.com/r4fK9kH

      Me reste plus cas faire afficher mes variable joystick, et enfin, je passe au reseau et à la camera !!!

      UN GRAND GRAND MERCI à ----->DAL<------
      0
  3. poparnassus Messages postés 462 Statut Membre 31
     
    Une question:

     int w = 5 , h = 5;
        SDL_FreeSurface(wt_SDL->SJoy12);
        SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
        sprintf(input->JGXX, "X : %d",input->JGX);
    
        wt_SDL->SJoy12 = TTF_RenderText_Solid(wt_SDL->police,input->JGXX,wt_SDL->couleurNoire);
        wt_SDL->TJoy12 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy12);
    
        SDL_QueryTexture(wt_SDL->TJoy12, NULL, NULL, &w, &h);
        SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy12, NULL, &wt_SDL->Joy12);
        SDL_RenderPresent(wt_SDL->renderer);


    Dans ma boucle principale du main j'appele une fonction qui execute le code ci dessous, j'ai mais valeur d'axe joystick qui s'affiche mais la surface ne s'efface pas a chaque tour de boucle, du coup ca fait un gros patter tout noir ^^
    0
    1. poparnassus Messages postés 462 Statut Membre 31
       
      J'ai modifier comme ceci, ca marche mais j'ai un probleme de memoire, je travaille dessus.

      //JGX
           int w = 5 , h = 5;
          SDL_FreeSurface(wt_SDL->SJoy12);
          sprintf(input->JGXX, "X: %d",input->JGX);
          SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
      
          SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy12);
          wt_SDL->SJoy12 = TTF_RenderText_Solid(wt_SDL->police,input->JGXX,wt_SDL->couleurNoire);
          wt_SDL->TJoy12 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy12);
          SDL_QueryTexture(wt_SDL->TJoy12, NULL, NULL, &w, &h);
          SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy12, NULL, &wt_SDL->Joy12);
      
      0
    2. poparnassus Messages postés 462 Statut Membre 31
       
      J'AI REUSSI !!! Maintenant je passe au reseau !!
      0
    3. poparnassus Messages postés 462 Statut Membre 31
       
      J'ai une question, est il n,écessaire de concatener mes variables joystick dans une seul variable pour les envoyer sur le reseau ?
      envoyer un bloc me parait mieux que plusieurs bloc mais bon, je sais pas trop en faite.
      0
  4. poparnassus Messages postés 462 Statut Membre 31
     
    La suite dans un future topic
    MERCI
    0
    1. poparnassus Messages postés 462 Statut Membre 31
       
      CODE SOURCE FINAL EN C:
      pré-requis
      - librairies SDL2.0
      - librairies SDL2_ttf
      - 1 manette xbox360

      Dans ce code, qui a pour objectif de piloter un robot via mon reseau local:

      Depuis mon interface qui sera donc le "serveur", je récupère des événements manette XBOX + clavier, je les affiches dans une fenêtre scindée en deux partie (le haut pour la partie controle joystick et retour capteur, et le bas affichage de la camera).
      Dans ce code je ne traite pas les informations liées au réseau, je ferai ceci prochainement.

      main.c
      #include "fonction.h"
      
      
      
      int main(int argc, char** argv)
      {
          fichierLog = fopen("LOG.txt", "w+"); // Creation du fichier log
      
          //Creation des structures
          Input input;
          wt_SDL wt_SDL;
      
          //Init de SDL_VIDEO , SDL_JOYSTICK , SDL_TTF
          initialisation(" Programme Wild Thumper: Station de pilotage ",&wt_SDL);
      
          //initialisation des structures
          RAZ_input(&input); //init input + evenement joystick
          RAZ_wt_SDL(&wt_SDL) ;
      
          //Creation des surfaces de la fenetre
          ArrierePlan(&input, &wt_SDL);
      
          //calibration_joystick(&input, &wt_SDL);
      
          ArrierePlan_TTF(&input, &wt_SDL);
      
      
          while (!input.quitter)
          {
              updateEvent(&input);
      
              if (input.mode_pilotage == 1)
              {
                  modepilotage1(&input, &wt_SDL);
      
      
              }
      
              else if (input.mode_pilotage == 2)
              {
                  modepilotage2(&input, &wt_SDL); //Warnig du compilateur, j'ai pas trouver poourquoi
              }
      
              envoiData(&input);
      
      
              SDL_Delay(10);
              system("cls");
          }
      
          SDL_JoystickClose(input.joystick);
      
          cleanup(&wt_SDL);
          system("pause");
          return 0;
      }
      
      


      fonction.c
      #include "fonction.h"
      
      //Initialisation SDL
      void initialisation(const char *titre,wt_SDL *wt_SDL)
      {
          if (SDL_Init( SDL_INIT_VIDEO |SDL_INIT_JOYSTICK) != 0)
          {
              fprintf(fichierLog,"Impossible de charger la SDL. SDL_ERROR = %s \n", SDL_GetError());
              EXIT_FAILURE;
          }
          else
          {
          //Creation de la fenetre
          wt_SDL->screen = SDL_CreateWindow(titre,SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,WINDOW_W,WINDOW_H,SDL_WINDOW_SHOWN);
          //Creation du renderer
          wt_SDL->renderer = SDL_CreateRenderer( wt_SDL->screen,-1,SDL_RENDERER_ACCELERATED);
      
              if ( wt_SDL->screen == NULL ||  wt_SDL->renderer == NULL)
              {
                  fprintf(fichierLog,"Impossible d'initialiser le mode ecran %s ,\n", SDL_GetError());
              }
          }
      
          //Initialisation TTF Pour ecrire du texte dans la fenetre SDL
          if(TTF_Init() != 0)
          {
              fprintf(fichierLog,"Impossible de charger la SDL2_TTF_Init. SDL_ERROR =  %s\n", TTF_GetError());
              EXIT_FAILURE;
          }
          else
          {
              wt_SDL->police = TTF_OpenFont("Caslon.ttf",18);
              if(wt_SDL->police == NULL)
              {
                   fprintf(fichierLog,"Impossible de charger la police Calson.ttf . SDL_ERROR =  %s\n\n", TTF_GetError());
                   EXIT_FAILURE;
              }
      
              wt_SDL->couleurNoire.a = 0;
              wt_SDL->couleurNoire.b = 0;
              wt_SDL->couleurNoire.g = 0;
              wt_SDL->couleurNoire.r = 0;
      
              wt_SDL->couleurRouge.a = 0;
              wt_SDL->couleurRouge.b = 0;
              wt_SDL->couleurRouge.g = 0;
              wt_SDL->couleurRouge.r = 255;
      
              wt_SDL->couleurBlanche.a = 255;
              wt_SDL->couleurBlanche.b = 255;
              wt_SDL->couleurBlanche.g = 255;
              wt_SDL->couleurBlanche.r = 255;
      
      
          }
      }
      //Initialisation structure
      void RAZ_input(Input *input)
      {
          SDL_JoystickEventState(SDL_ENABLE);
      
          //Verifie si un joystixk est connecter
          if (SDL_NumJoysticks() < 1)
          {
              fprintf(fichierLog,"Pas de joystick connecter. \n");
              EXIT_FAILURE;
          }
      
          input->joystick = SDL_JoystickOpen(0);
          input->quitter = 0;
          input->quittermode = 0;
          //float upJGX=0;
          //float upJGY =0;
          //float upJDX=0;
          //float upJDY=0;
          input->data[200] =0;
          input->JGXX[10] = 0;
          input->JGYY[10] = 0;
          input->JDXX[10] = 0;
          input->JDYY[10] = 0;
      
          input->JGX = 0; //position tableau = 0
          input->JGY = 0; //position tableau = 1
          input->JDX = 0; //position tableau = 2
          input->JDY = 0; //position tableau = 3
          input->BOUTTON_A = 0; //position tableau = 4 - 0 Pour Boutton Relacher
          input->BOUTTON_B = 0;//position tableau = 5
          input->BOUTTON_Y = 0;//position tableau = 6
          input->BOUTTON_X = 0;//position tableau = 7
          input->BOUTTON_LB = 0; //position tableau = 8 boutton Gauche
          input->BOUTTON_RB = 0; //position tableau = 9 boutton droite
          input->BOUTTON_START = 0;//position tableau = 10
          input->BOUTTON_BACK = 0; //position tableau = 11
          //Zone morte
          input->DEADZONE_P = 8000;
          input->DEADZONE_N = -8000;
      
          //Mode de pilotage
          input->mode_pilotage = 0;
      }
      void RAZ_wt_SDL(wt_SDL *wt_SDL)
      {
          //Allocation de la memoire
      
          //wt_SDL->rectangle1 = (SDL_Rect *)malloc(sizeof (SDL_Rect));
          //initialisation des variables de la structure
          wt_SDL->RTITRE.x = 0;
          wt_SDL->RTITRE.y = 0;
          wt_SDL->RTITRE.w = 0;
          wt_SDL->RTITRE.h = 0;
      
          wt_SDL->rectangle1.x = 0;
          wt_SDL->rectangle1.y = 0;
          wt_SDL->rectangle1.w = 0;
          wt_SDL->rectangle1.h = 0;
      
          //wt_SDL->rectangle1 =  SDL_CreateRGBSurface(SDL_HWSURFACE,&wt_SDL->rectangle1.w,&wt_SDL->rectangle1.h,32,0,0,0,0);
      
              wt_SDL->rectangleMID.x= 0;
              wt_SDL->rectangleMID.y=0;
              wt_SDL->rectangleMID.w=0;
              wt_SDL->rectangleMID.h=0;
      
              wt_SDL->rectangleA.x= 0;
              wt_SDL->rectangleA.y=0;
              wt_SDL->rectangleA.w=0;
              wt_SDL->rectangleA.h=0;
      
              wt_SDL->rectangleB.x=0;
              wt_SDL->rectangleB.y=0;
              wt_SDL->rectangleB.w=0;
              wt_SDL->rectangleB.h=0;
      
              wt_SDL->rectangleX.x=0;
              wt_SDL->rectangleX.y=0;
              wt_SDL->rectangleX.w=0;
              wt_SDL->rectangleX.h=0;
      
              wt_SDL->rectangleY.x=0;
              wt_SDL->rectangleY.y=0;
              wt_SDL->rectangleY.w=0;
              wt_SDL->rectangleY.h=0;
      
                  wt_SDL->Joy1.x = 0;
                  wt_SDL->Joy1.y = 0;
                  wt_SDL->Joy1.w = 0;
                  wt_SDL->Joy1.h = 0;
      
      
                      wt_SDL->Joy11.w =0;
                      wt_SDL->Joy11.h =0;
                      wt_SDL->Joy11.x =0;
                      wt_SDL->Joy11.y =0;
      
                      wt_SDL->Joy12.w =0;
                      wt_SDL->Joy12.h =0;
                      wt_SDL->Joy12.x =0;
                      wt_SDL->Joy12.y =0;
      
                      wt_SDL->Joy13.w =0;
                      wt_SDL->Joy13.h =0;
                      wt_SDL->Joy13.x =0;
                      wt_SDL->Joy13.y =0;
      
                  wt_SDL->Joy2.x = 0;
                  wt_SDL->Joy2.y = 0;
                  wt_SDL->Joy2.w = 0;
                  wt_SDL->Joy2.h = 0;
      
                      wt_SDL->Joy21.w =0;
                      wt_SDL->Joy21.h =0;
                      wt_SDL->Joy21.x =0;
                      wt_SDL->Joy21.y =0;
      
                      wt_SDL->Joy22.w =0;
                      wt_SDL->Joy22.h =0;
                      wt_SDL->Joy22.x =0;
                      wt_SDL->Joy22.y =0;
      
                      wt_SDL->Joy23.w =0;
                      wt_SDL->Joy23.h =0;
                      wt_SDL->Joy23.x =0;
                      wt_SDL->Joy23.y =0;
      
              wt_SDL->case1.x=0;
              wt_SDL->case1.y=0;
              wt_SDL->case1.w=0;
              wt_SDL->case1.h=0;
      
              wt_SDL->case2.x=0;
              wt_SDL->case2.y=0;
              wt_SDL->case2.w=0;
              wt_SDL->case2.h=0;
      
              wt_SDL->case3.x=0;
              wt_SDL->case3.y=0;
              wt_SDL->case3.w=0;
              wt_SDL->case3.h=0;
      
              wt_SDL->case4.x=0;
              wt_SDL->case4.y=0;
              wt_SDL->case4.w=0;
              wt_SDL->case4.h=0;
      
              wt_SDL->case5.x=0;
              wt_SDL->case5.y=0;
              wt_SDL->case5.w=0;
              wt_SDL->case5.h=0;
      
              wt_SDL->case6.x=0;
              wt_SDL->case6.y=0;
              wt_SDL->case6.w=0;
              wt_SDL->case6.h=0;
      
          wt_SDL->rectangleCAM.x=0;
          wt_SDL->rectangleCAM.y=0;
          wt_SDL->rectangleCAM.w=0;
          wt_SDL->rectangleCAM.h=0;
      
              wt_SDL->calibrer.x = 0;
              wt_SDL->calibrer.y = 0;
              wt_SDL->calibrer.w = 0;
              wt_SDL->calibrer.h = 0;
      
              wt_SDL->cal_titre.x = 0;
              wt_SDL->cal_titre.y = 0;
              wt_SDL->cal_titre.w = 0;
              wt_SDL->cal_titre.h = 0;
      
      
      
      
      
      
      }
      //Fonction QUITTER ------------------------
      void cleanup(wt_SDL *wt_SDL)
      {
          //Déstruction des  textures
          SDL_DestroyTexture(wt_SDL->Image_fond); //Image de fond
      
          SDL_DestroyTexture(wt_SDL->TRAtext); // Bouuton A
          SDL_DestroyTexture(wt_SDL->TRYtext); // Y
          SDL_DestroyTexture(wt_SDL->TRXtext);// X
          SDL_DestroyTexture(wt_SDL->TRBtext);// B
      
          SDL_DestroyTexture(wt_SDL->TJoy13);
          SDL_DestroyTexture(wt_SDL->TJoy12);
          SDL_DestroyTexture(wt_SDL->TJoy11);
          SDL_DestroyTexture(wt_SDL->TJoy23);
          SDL_DestroyTexture(wt_SDL->TJoy22);
          SDL_DestroyTexture(wt_SDL->TJoy21);
          SDL_DestroyTexture(wt_SDL->TJoy1);
          SDL_DestroyTexture(wt_SDL->TJoy1);
      
          SDL_DestroyTexture(wt_SDL->Tcase1);
          SDL_DestroyTexture(wt_SDL->Tcase2);
          SDL_DestroyTexture(wt_SDL->Tcase3);
          SDL_DestroyTexture(wt_SDL->Tcase4);
          SDL_DestroyTexture(wt_SDL->Tcase5);
          SDL_DestroyTexture(wt_SDL->Tcase6);
      
          //Déstruction des surfaces
          SDL_FreeSurface(wt_SDL->SJoy13);
          SDL_FreeSurface(wt_SDL->SJoy12);
          SDL_FreeSurface(wt_SDL->SJoy11);
          SDL_FreeSurface(wt_SDL->SJoy23);
          SDL_FreeSurface(wt_SDL->SJoy22);
          SDL_FreeSurface(wt_SDL->SJoy21);
          SDL_FreeSurface(wt_SDL->SJoy1);
          SDL_FreeSurface(wt_SDL->SJoy1);
      
          SDL_FreeSurface(wt_SDL->RAtext);// Boutton A
          SDL_FreeSurface( wt_SDL->RYtext);// Y
          SDL_FreeSurface( wt_SDL->RXtext );// X
          SDL_FreeSurface( wt_SDL->RBtext);// B
      
          SDL_FreeSurface( wt_SDL->Scase1);
          SDL_FreeSurface( wt_SDL->Scase2);
          SDL_FreeSurface( wt_SDL->Scase3);
          SDL_FreeSurface( wt_SDL->Scase4);
          SDL_FreeSurface( wt_SDL->Scase5);
          SDL_FreeSurface( wt_SDL-> Scase6);
      
          SDL_FreeSurface(wt_SDL->Image); // Image de fond
      
          SDL_DestroyRenderer(wt_SDL->renderer);
          SDL_DestroyWindow(wt_SDL->screen);
      
          TTF_CloseFont(wt_SDL->police);
      
          fclose(fichierLog);
      
          TTF_Quit();
          SDL_Quit();
      }
      
      //--------------------------------
      void ArrierePlan(Input *input, wt_SDL *wt_SDL)
      {
          SDL_RenderPresent(wt_SDL->renderer);
              SDL_SetRenderDrawColor(wt_SDL->renderer, 0, 0, 0, 255); // NOIR
              SDL_RenderClear(wt_SDL->renderer);
      
              //Partie commande
              {
                  wt_SDL->rectangle1.x = 20;
                  wt_SDL->rectangle1.y = 20;
                  wt_SDL->rectangle1.w = WINDOW_W - (wt_SDL->rectangle1.x*2);
                  wt_SDL->rectangle1.h =  WINDOW_H/4;
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,0,0,0); // blanc
                  SDL_RenderFillRect(wt_SDL->renderer,&wt_SDL->rectangle1);
      
                  wt_SDL->RTITRE.x = wt_SDL->rectangle1.w/2 - ((wt_SDL->rectangle1.w / 3)/2);
                  wt_SDL->RTITRE.y = wt_SDL->rectangle1.y;
                  wt_SDL->RTITRE.w = WINDOW_W/3;
                  wt_SDL->RTITRE.h = 40;
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); // blanc
                  SDL_RenderFillRect(wt_SDL->renderer,&wt_SDL->RTITRE);
      
                      { //Boutton A B X Y
                      int touche=40;
                      //BOUTTON Y
                      wt_SDL->rectangleY.x = wt_SDL->rectangle1.x + (wt_SDL->rectangle1.w/2)-(touche/2) ; //centre du rectangle 1
                      wt_SDL->rectangleY.y = wt_SDL->rectangle1.h - (touche * 3);
                      wt_SDL->rectangleY.w = touche;
                      wt_SDL->rectangleY.h = touche;
                      SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                      SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleY);
                      //BOUTTON A
                      wt_SDL->rectangleA.x = wt_SDL->rectangleY.x;
                      wt_SDL->rectangleA.y = wt_SDL->rectangleY.y + touche*2;
                      wt_SDL->rectangleA.w = touche;
                      wt_SDL->rectangleA.h = touche;
                      SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                      SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleA);
                      //BOUTTON B
                      wt_SDL->rectangleB.x = wt_SDL->rectangleY.x + touche;
                      wt_SDL->rectangleB.y = wt_SDL->rectangleY.y + touche;
                      wt_SDL->rectangleB.w = touche;
                      wt_SDL->rectangleB.h = touche;
                      SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255);
                      SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleB);
                      //BOUTTON X
                      wt_SDL->rectangleX.x = wt_SDL->rectangleY.x - touche;
                      wt_SDL->rectangleX.y = wt_SDL->rectangleY.y + touche;
                      wt_SDL->rectangleX.w = touche;
                      wt_SDL->rectangleX.h = touche;
                      SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                      SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleX);
                      //Carré du milieu
                      wt_SDL->rectangleMID.x = wt_SDL->rectangleY.x;
                      wt_SDL->rectangleMID.y = wt_SDL->rectangleY.y + touche;
                      wt_SDL->rectangleMID.w = touche;
                      wt_SDL->rectangleMID.h = touche;
                      SDL_SetRenderDrawColor(wt_SDL->renderer,0,0,0,255); //NOIR
                      SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleMID);
      
                       //Position par rapport a la touche X
                       int marge=10;
                      wt_SDL->Joy1.w = wt_SDL->rectangleMID.w+wt_SDL->rectangleA.w+wt_SDL->rectangleY.w+30;
                      wt_SDL->Joy1.h = wt_SDL->rectangleMID.h+wt_SDL->rectangleA.h+wt_SDL->rectangleY.h;
                      wt_SDL->Joy1.x = wt_SDL->rectangleX.x - wt_SDL->Joy1.w - marge;
                      wt_SDL->Joy1.y = wt_SDL->rectangleY.y;
                      SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                      SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy1);
      
                          wt_SDL->Joy11.w =wt_SDL->Joy1.w;
                          wt_SDL->Joy11.h =wt_SDL->Joy1.h/3;
                          wt_SDL->Joy11.x =wt_SDL->Joy1.x;
                          wt_SDL->Joy11.y =wt_SDL->Joy1.y;
                          SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                          SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy11);
      
                          wt_SDL->Joy12.w =wt_SDL->Joy11.w;
                          wt_SDL->Joy12.h =wt_SDL->Joy11.h;
                          wt_SDL->Joy12.x =wt_SDL->Joy11.x ;
                          wt_SDL->Joy12.y =wt_SDL->Joy11.y + wt_SDL->Joy12.h;
                          SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                          SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy12);
      
                          wt_SDL->Joy13.w =wt_SDL->Joy12.w;
                          wt_SDL->Joy13.h =wt_SDL->Joy12.h;
                          wt_SDL->Joy13.x =wt_SDL->Joy12.x ;
                          wt_SDL->Joy13.y =wt_SDL->Joy12.y + wt_SDL->Joy13.h;
                          SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                          SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy13);
      
                      //Position par rapport a la touche B
                      wt_SDL->Joy2.w = wt_SDL->rectangleMID.w+wt_SDL->rectangleA.w+wt_SDL->rectangleY.w+30;
                      wt_SDL->Joy2.h = wt_SDL->rectangleMID.h+wt_SDL->rectangleA.h+wt_SDL->rectangleY.h;
                      wt_SDL->Joy2.x = wt_SDL->rectangleB.x + wt_SDL->rectangleX.w + marge;
                      wt_SDL->Joy2.y = wt_SDL->rectangleY.y;
                      SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                      SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy2);
      
                          wt_SDL->Joy21.w =wt_SDL->Joy2.w;
                          wt_SDL->Joy21.h =wt_SDL->Joy2.h/3;
                          wt_SDL->Joy21.x =wt_SDL->Joy2.x;
                          wt_SDL->Joy21.y =wt_SDL->Joy2.y;
                          SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                          SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy21);
      
                          wt_SDL->Joy22.w =wt_SDL->Joy21.w;
                          wt_SDL->Joy22.h =wt_SDL->Joy21.h;
                          wt_SDL->Joy22.x =wt_SDL->Joy21.x;
                          wt_SDL->Joy22.y =wt_SDL->Joy21.y + wt_SDL->Joy22.h;
                          SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                          SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy22);
      
                          wt_SDL->Joy23.w =wt_SDL->Joy22.w;
                          wt_SDL->Joy23.h =wt_SDL->Joy22.h;
                          wt_SDL->Joy23.x =wt_SDL->Joy22.x;
                          wt_SDL->Joy23.y =wt_SDL->Joy22.y + wt_SDL->Joy23.h;
                          SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                          SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy23);
                      }
      
      
                      //Bouttons colonne gauche - 6 bouttons
                      {
                      int casew = (wt_SDL->rectangle1.h / 4)*2 , caseh = wt_SDL->rectangle1.h / 6 ;
                      wt_SDL->case1.x = wt_SDL->rectangle1.x;
                      wt_SDL->case1.y = wt_SDL->rectangle1.y;
                      wt_SDL->case1.w = casew ;
                      wt_SDL->case1.h = caseh;
                      SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //GRIS
                      SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->case1);
      
                      wt_SDL->case2.x = wt_SDL->case1.x;
                      wt_SDL->case2.y = wt_SDL->case1.y + caseh;
                      wt_SDL->case2.w = casew ;
                      wt_SDL->case2.h = caseh;
                      SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255);
                      SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->case2);
      
                      wt_SDL->case3.x = wt_SDL->case2.x;
                      wt_SDL->case3.y = wt_SDL->case2.y + caseh;
                      wt_SDL->case3.w = casew ;
                      wt_SDL->case3.h = caseh;
                      SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255);
                      SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->case3);
      
                      wt_SDL->case4.x = wt_SDL->case3.x;
                      wt_SDL->case4.y = wt_SDL->case3.y + caseh;
                      wt_SDL->case4.w = casew ;
                      wt_SDL->case4.h = caseh;
                      SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255);
                      SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->case4);
      
                      wt_SDL->case5.x = wt_SDL->case4.x;
                      wt_SDL->case5.y = wt_SDL->case4.y + caseh;
                      wt_SDL->case5.w = casew ;
                      wt_SDL->case5.h = caseh;
                      SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                      SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->case5);
      
                      wt_SDL->case6.x = wt_SDL->case5.x;
                      wt_SDL->case6.y = wt_SDL->case5.y + caseh;
                      wt_SDL->case6.w = casew ;
                      wt_SDL->case6.h = caseh;
                      SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                      SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->case6);
                      }
              }
              //Affichage Camera
              //if(wt_SDL->rectangleCAM != NULL)
              {
                  wt_SDL->rectangleCAM.x = wt_SDL->rectangle1.x;
                  wt_SDL->rectangleCAM.y = wt_SDL->rectangle1.h + (wt_SDL->rectangle1.y * 2) ;
                  wt_SDL->rectangleCAM.w = wt_SDL->rectangle1.w;
                  wt_SDL->rectangleCAM.h = WINDOW_H - (wt_SDL->rectangle1.h + (wt_SDL->rectangle1.y*3) );
      
      
      
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleCAM);
                  SDL_RenderPresent(wt_SDL->renderer);
      
      
      
                  SDL_RenderPresent(wt_SDL->renderer);
              }
      }
      void ArrierePlan_TTF(Input *input, wt_SDL *wt_SDL)
      {
          wt_SDL->Image = SDL_LoadBMP("6wd.bmp"); // SDL SURFACE
                  if (wt_SDL->Image == NULL)
                      {
                          fprintf(fichierLog,"Pas d'image trouver\n\n");
                      }
                  wt_SDL->Image_fond = SDL_CreateTextureFromSurface(wt_SDL->renderer,wt_SDL->Image); //SDL TEXTURE
      
                  SDL_RenderCopy(wt_SDL->renderer,wt_SDL->Image_fond,NULL,&wt_SDL->rectangleCAM);
      
      
          {
              //TITRE
              int w = 10, h = 10;
              wt_SDL->STITRE = TTF_RenderText_Blended(wt_SDL->police, " STATION DE PILOTAGE",wt_SDL->couleurNoire);
              wt_SDL->TTITRE = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->STITRE);
              SDL_QueryTexture(wt_SDL->TTITRE, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TTITRE, NULL, &wt_SDL->RTITRE);
              SDL_RenderPresent(wt_SDL->renderer);
          }
      
          {
              int w = 5, h = 5;
              //BOUTTON
              wt_SDL->RAtext = TTF_RenderText_Solid(wt_SDL->police, "A",wt_SDL->couleurNoire); // SURFACE
              wt_SDL->TRAtext = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->RAtext); //TEXTURE
              SDL_QueryTexture(wt_SDL->TRAtext, NULL, NULL, &w, &h);
      
              wt_SDL->RBtext = TTF_RenderText_Solid(wt_SDL->police, "B",wt_SDL->couleurNoire);
              wt_SDL->TRBtext = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->RBtext);
              SDL_QueryTexture(wt_SDL->TRBtext, NULL, NULL, &w, &h);
      
              wt_SDL->RXtext = TTF_RenderText_Solid(wt_SDL->police, "X",wt_SDL->couleurNoire);
              wt_SDL->TRXtext = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->RXtext);
              SDL_QueryTexture(wt_SDL->TRXtext, NULL, NULL, &w, &h);
      
              wt_SDL->RYtext = TTF_RenderText_Solid(wt_SDL->police, "Y",wt_SDL->couleurNoire);
              wt_SDL->TRYtext = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->RYtext);
              SDL_QueryTexture(wt_SDL->TRYtext, NULL, NULL, &w, &h);
          }
      
          {
              int w = 10 , h = 10;
              wt_SDL->SJoy11 = TTF_RenderText_Blended(wt_SDL->police, "JOYSTICK GAUCHE",wt_SDL->couleurRouge);
              wt_SDL->TJoy11 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy11);
              SDL_QueryTexture(wt_SDL->TJoy11, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy11, NULL, &wt_SDL->Joy11);
      
              wt_SDL->SJoy12 = TTF_RenderText_Blended(wt_SDL->police,"axe X",wt_SDL->couleurNoire);
              wt_SDL->TJoy12 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy12);
              SDL_QueryTexture(wt_SDL->TJoy12, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy12, NULL, &wt_SDL->Joy12);
      
              wt_SDL->SJoy13 = TTF_RenderText_Blended(wt_SDL->police, "axe Y",wt_SDL->couleurNoire);
              wt_SDL->TJoy13 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy13);
              SDL_QueryTexture(wt_SDL->TJoy13, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy13, NULL, &wt_SDL->Joy13);
      
              wt_SDL->SJoy21 = TTF_RenderText_Blended(wt_SDL->police, "JOYSTICK DROITE",wt_SDL->couleurRouge);
              wt_SDL->TJoy21 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy21);
              SDL_QueryTexture(wt_SDL->TJoy21, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy21, NULL, &wt_SDL->Joy21);
      
              wt_SDL->SJoy22 = TTF_RenderText_Blended(wt_SDL->police, "axe X",wt_SDL->couleurNoire);
              wt_SDL->TJoy22 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy22);
              SDL_QueryTexture(wt_SDL->TJoy22, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy22, NULL, &wt_SDL->Joy22);
      
              wt_SDL->SJoy23 = TTF_RenderText_Blended(wt_SDL->police, "axe Y",wt_SDL->couleurNoire);
              wt_SDL->TJoy23 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy23);
              SDL_QueryTexture(wt_SDL->TJoy23, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy23, NULL, &wt_SDL->Joy23);
              SDL_RenderPresent(wt_SDL->renderer);
          }
      
          {
              int w = 10 , h = 10;
              wt_SDL->Scase1 = TTF_RenderText_Blended(wt_SDL->police, "Raspberry ON/OFF",wt_SDL->couleurRouge);
              wt_SDL->Tcase1 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->Scase1);
              SDL_QueryTexture(wt_SDL->Tcase1, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->Tcase1, NULL, &wt_SDL->case1);
      
              wt_SDL->Scase2 = TTF_RenderText_Blended(wt_SDL->police, "Arduino ON/OFF",wt_SDL->couleurRouge);
              wt_SDL->Tcase2 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->Scase2);
              SDL_QueryTexture(wt_SDL->Tcase2, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->Tcase2, NULL, &wt_SDL->case2);
      
              wt_SDL->Scase3 = TTF_RenderText_Blended(wt_SDL->police, "",wt_SDL->couleurRouge);
              wt_SDL->Tcase3 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->Scase3);
              SDL_QueryTexture(wt_SDL->Tcase3, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->Tcase3, NULL, &wt_SDL->case3);
      
              wt_SDL->Scase4 = TTF_RenderText_Blended(wt_SDL->police, "",wt_SDL->couleurRouge);
              wt_SDL->Tcase4= SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->Scase4);
              SDL_QueryTexture(wt_SDL->Tcase4, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->Tcase4, NULL, &wt_SDL->case4);
      
              wt_SDL->Scase5 = TTF_RenderText_Blended(wt_SDL->police, "Signal Wifi: 00%",wt_SDL->couleurRouge);
              wt_SDL->Tcase5 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->Scase5);
              SDL_QueryTexture(wt_SDL->Tcase5, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->Tcase5, NULL, &wt_SDL->case5);
      
              wt_SDL->Scase6 = TTF_RenderText_Blended(wt_SDL->police, "Niveau batterie: 00%",wt_SDL->couleurRouge);
              wt_SDL->Tcase6 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->Scase6);
              SDL_QueryTexture(wt_SDL->Tcase6, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->Tcase6, NULL, &wt_SDL->case6);
          }
      
      SDL_RenderPresent(wt_SDL->renderer);
      
      }
      
      //Evenement Clavier-Joystick
      void updateEvent(Input *input)
      {
          static SDL_Event e;
      
              while (SDL_PollEvent(&e))
              {
                  if (SDL_NumJoysticks() < 1)
                  {
                      fprintf(fichierLog, "Joystick deconnecter pendant l'execution du programme \n\n");
                      input->quitter = 1;
                  }
                  if (e.type == SDL_KEYDOWN)
                  {
                      if (e.key.keysym.sym == SDLK_ESCAPE)
                      {
                          input->quitter = 1;
                      }
                  }
                  if (e.type == SDL_WINDOWEVENT)
                  {
                      if (e.window.event == SDL_WINDOWEVENT_CLOSE)
                      {
                          input->quitter = 1;
                      }
                  }
      
                  if (e.type == SDL_JOYAXISMOTION)  //ICI on gere les axes du joystique donc JGX, JGY, JDX, JDY
                  {
                      //Si le chapeau Gauche a détecté un mouvement
                      if (e.jaxis.which == 0)
                      {
                      //Si le mouvement a eu lieu sur l'axe des X
                          if (e.jaxis.axis == 0)
                          {
                              //Si l'axe des X est neutre ou à l'intérieur de la "dead zone", je recupere J0X
                              if ((e.jaxis.value > input->DEADZONE_N) && (e.jaxis.value < input->DEADZONE_P))
                              {
                                  input->JGX = 0;
                              }
                              else
                              {
                                  if (e.jaxis.value < input->DEADZONE_N)
                                  {
                                      input->JGX = e.jaxis.value - input->DEADZONE_N;
                                  }
                                  else if (e.jaxis.value > input->DEADZONE_P)
                                  {
                                      input->JGX = e.jaxis.value - input->DEADZONE_P ;
                                  }
                              }
                          }
                          //Si le mouvement a eu lieu sur l'axe des Y, je recupere J0Y
                          else if (e.jaxis.axis == 1)
                          {
                              //Si l'axe des Y est neutre ou à l'intérieur de la "dead zone"
                              if ((e.jaxis.value > input->DEADZONE_N) && (e.jaxis.value < input->DEADZONE_P))
                              {
                                  input->JGY = 0;
                              }
                              else
                              {
                                  if (e.jaxis.value < input->DEADZONE_N)
                                  {
                                      input->JGY = -(e.jaxis.value - input->DEADZONE_N);
                                  }
                                  else if (e.jaxis.value > input->DEADZONE_P)
                                  {
                                      input->JGY = -(e.jaxis.value - input->DEADZONE_P);
                                  }
                              }
                          }
                          //Si le mouvement a eu lieu sur l'axe des X
                          if (e.jaxis.axis == 2)
                          {
                              //Si l'axe des X est neutre ou à l'intérieur de la "dead zone", je recupere J0X
                              if ((e.jaxis.value > input->DEADZONE_N) && (e.jaxis.value < input->DEADZONE_P))
                              {
                                  input->JDX = 0;
                              }
                              else
                              {
                                  if (e.jaxis.value < input->DEADZONE_N)
                                  {
                                      input->JDX = e.jaxis.value - input->DEADZONE_N;
                                  }
                                  else if (e.jaxis.value > input->DEADZONE_P)
                                  {
                                      input->JDX = e.jaxis.value - input->DEADZONE_P;
                                  }
                              }
                          }
                          //Si le mouvement a eu lieu sur l'axe des Y, je recupere J0Y
                          else if (e.jaxis.axis == 3)
                          {
                              //Si l'axe des Y est neutre ou à l'intérieur de la "dead zone"
                              if ((e.jaxis.value > input->DEADZONE_N) && (e.jaxis.value < input->DEADZONE_P))
                              {
                                  input->JDY = 0;
                              }
                              else
                              {
                                  if (e.jaxis.value < input->DEADZONE_N)
                                  {
                                      input->JDY = -(e.jaxis.value - input->DEADZONE_N);
                                  }
                                  else if (e.jaxis.value > input->DEADZONE_P)
                                  {
                                      input->JDY = -(e.jaxis.value - input->DEADZONE_P);
                                  }
                              }
                          }
                      }
                  }
      
                  if (e.type == SDL_JOYBUTTONDOWN) //ICI on gere les bouttons BOUTTON APPUYER
                  {
                      if (e.jbutton.button == 10)
                      {
                          input->BOUTTON_A = 1;
                      }
                      else if (e.jbutton.button == 11)
                      {
                          input->BOUTTON_B = 1;
                      }
                      else if (e.jbutton.button == 12)
                      {
                          input->BOUTTON_X = 1;
                      }
                      else if (e.jbutton.button == 13)
                      {
                          input->BOUTTON_Y = 1;
                      }
                      else if (e.jbutton.button == 8)
                      {
                          input->BOUTTON_LB = 1;
                          input->mode_pilotage =1;
                          //tableau[8]= 1;
                      }
                      else if (e.jbutton.button == 9)
                      {
                          input->BOUTTON_RB =1;
                           input->mode_pilotage =2;
                          //tableau[9]= 1;
                      }
                      else if ( e.jbutton.button == 4)
                      {
                          input->BOUTTON_START=1;
                      }
                      else if (e.jbutton.button == 5)
                      {
                          input->BOUTTON_BACK = 1;
                          input->quitter = 1;
                      }
                  }
                  else if (e.type == SDL_JOYBUTTONUP)
                  {
                       if (e.jbutton.button == 10)
                      {
                          input->BOUTTON_A = 0;
                      }
                      else if (e.jbutton.button == 11)
                      {
                          input->BOUTTON_B = 0;
                      }
                      else if (e.jbutton.button == 12)
                      {
                          input->BOUTTON_X = 0;
                      }
                      else if (e.jbutton.button == 13)
                      {
                          input->BOUTTON_Y = 0;
                      }
                      else if (e.jbutton.button == 8)
                      {
                          input->BOUTTON_LB = 0;
                      }
                      else if (e.jbutton.button == 9)
                      {
                          input->BOUTTON_RB =0;
                      }
                      else if ( e.jbutton.button == 4)
                      {
                          input->BOUTTON_START=0;
                      }
                      else if (e.jbutton.button == 5)
                      {
                          input->BOUTTON_BACK = 0;
                      }
                  }
              }
      }
      
      //Mode de pilotage
      void modepilotage2(Input *input, wt_SDL *wt_SDL)
      {
          input->JGX_Max = 24767 ;
          input->JGY_Max = 24767 ;
          input->JDX_Max = 24767 ;
          input->JDY_Max = 24767 ;
      
          input->JGX_Mx = (100 * input->JGX) / input->JGX_Max;
          input->JGY_Mx = (100 * input->JGY) / input->JGY_Max;
          input->JDX_Mx = (100 * input->JDX) / input->JDX_Max;
          input->JDY_Mx = (100 * input->JDY) / input->JDY_Max;
      
          int i;
          int tableauMD2[7]= {input->mode_pilotage,input->JGY_Mx,input->JDY_Mx,input->BOUTTON_A,input->BOUTTON_B,input->BOUTTON_Y,input->BOUTTON_X};
          for(i=0; i < 7; i++)
          {
              printf("= %d",tableauMD2[i]);
      
          }
      
      
          int w = 5 , h = 5;
      
          if(input->BOUTTON_X == 1)
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,0,0,255,0); //BLEU
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleX);
                  SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TRXtext, NULL, &wt_SDL->rectangleX);
                  SDL_RenderPresent(wt_SDL->renderer);
                  SDL_DestroyTexture(wt_SDL->TRXtext);
              }
              else
              {
                  //SDL_DestroyTexture(wt_SDL->TRXtext);
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255);
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleX);
                  SDL_RenderPresent(wt_SDL->renderer);
              }
      
              if(input->BOUTTON_Y == 1)
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,128,0,0); //ORANGE
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleY);
                  SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TRYtext, NULL, &wt_SDL->rectangleY);
                  SDL_RenderPresent(wt_SDL->renderer);
                  SDL_DestroyTexture(wt_SDL->TRYtext);
              }
               else
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255);
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleY);
                  SDL_RenderPresent(wt_SDL->renderer);
              }
      
              if(input->BOUTTON_A == 1)
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,0,255,64,0); //VERT
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleA);
                  SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TRAtext, NULL, &wt_SDL->rectangleA);
                  SDL_RenderPresent(wt_SDL->renderer);
                  SDL_DestroyTexture(wt_SDL->TRAtext);
              }
              else
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //VERT
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleA);
                  SDL_RenderPresent(wt_SDL->renderer);
              }
      
      
              if(input->BOUTTON_B == 1)
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,128,128,0);
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleB);
                  SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TRBtext, NULL, &wt_SDL->rectangleB);
                  SDL_RenderPresent(wt_SDL->renderer);
                  SDL_DestroyTexture(wt_SDL->TRBtext);
              }
              else
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255);
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleB);
                  SDL_RenderPresent(wt_SDL->renderer);
              }
      
      
      
          SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
          SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy22);
      
          wt_SDL->SJoy22 = TTF_RenderText_Blended(wt_SDL->police, "MODE 2",wt_SDL->couleurNoire);
          wt_SDL->TJoy22 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy22);
          SDL_QueryTexture(wt_SDL->TJoy22, NULL, NULL, &w, &h);
          SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy22, NULL, &wt_SDL->Joy22);
      
      
          SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
          SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy12);
      
          wt_SDL->SJoy12 = TTF_RenderText_Blended(wt_SDL->police,"MODE 2",wt_SDL->couleurNoire);
          wt_SDL->TJoy12 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy12);
          SDL_QueryTexture(wt_SDL->TJoy12, NULL, NULL, &w, &h);
          SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy12, NULL, &wt_SDL->Joy12);
      
          //JGY JGYY
          sprintf(input->JGYY, "Y: %d",input->JGY);
          SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
      
          SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy13);
          wt_SDL->SJoy13 = TTF_RenderText_Solid(wt_SDL->police,input->JGYY,wt_SDL->couleurRouge);
          wt_SDL->TJoy13 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy13);
          SDL_QueryTexture(wt_SDL->TJoy13, NULL, NULL, &w, &h);
          SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy13, NULL, &wt_SDL->Joy13);
      
          //JDY JDYY
          sprintf(input->JDYY, "Y: %d",input->JDY);
          SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
      
          SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy23);
          wt_SDL->SJoy23 = TTF_RenderText_Solid(wt_SDL->police,input->JDYY,wt_SDL->couleurRouge);
          wt_SDL->TJoy23 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy23);
          SDL_QueryTexture(wt_SDL->TJoy23, NULL, NULL, &w, &h);
          SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy23, NULL, &wt_SDL->Joy23);
      
          SDL_RenderPresent(wt_SDL->renderer);
      
          SDL_DestroyTexture(wt_SDL->TJoy23);
          SDL_DestroyTexture(wt_SDL->TJoy13);
          SDL_DestroyTexture(wt_SDL->TJoy12);
          SDL_DestroyTexture(wt_SDL->TJoy22);
      
          SDL_FreeSurface(wt_SDL->SJoy23);
          SDL_FreeSurface(wt_SDL->SJoy13);
          SDL_FreeSurface(wt_SDL->SJoy12);
          SDL_FreeSurface(wt_SDL->SJoy22);
      }
      void modepilotage1(Input *input, wt_SDL *wt_SDL)
      {
          input->JGX_Max = 24767 ;
          input->JGY_Max = 24767 ;
          input->JDX_Max = 24767 ;
          input->JDY_Max = 24767 ;
      
          input->JGX_Mx = (100 * input->JGX) / input->JGX_Max;
          input->JGY_Mx = (100 * input->JGY) / input->JGY_Max;
          input->JDX_Mx = (100 * input->JDX) / input->JDX_Max;
          input->JDY_Mx = (100 * input->JDY) / input->JDY_Max;
      
          int tableauMD1[9]= {input->mode_pilotage,input->JGX_Mx,input->JGY_Mx,input->JDX_Mx,input->JDY_Mx,input->BOUTTON_A,input->BOUTTON_B,input->BOUTTON_Y,input->BOUTTON_X};
          int i;
          for(i=0; i < 8; i++)
          {
              printf("= %d",tableauMD1[i]);
      
          }
      
          int w = 5 , h = 5;
      
          //
          if(input->BOUTTON_X == 1)
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,0,0,255,0); //BLEU
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleX);
                  SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TRXtext, NULL, &wt_SDL->rectangleX);
                  SDL_RenderPresent(wt_SDL->renderer);
              }
              else
              {
                  //SDL_DestroyTexture(wt_SDL->TRXtext);
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255);
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleX);
                  SDL_RenderPresent(wt_SDL->renderer);
              }
      
              if(input->BOUTTON_Y == 1)
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,128,0,0); //ORANGE
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleY);
                  SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TRYtext, NULL, &wt_SDL->rectangleY);
                  SDL_RenderPresent(wt_SDL->renderer);
              }
               else
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255);
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleY);
                  SDL_RenderPresent(wt_SDL->renderer);
              }
      
              if(input->BOUTTON_A == 1)
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,0,255,64,0); //VERT
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleA);
                  SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TRAtext, NULL, &wt_SDL->rectangleA);
                  SDL_RenderPresent(wt_SDL->renderer);
              }
              else
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //VERT
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleA);
                  SDL_RenderPresent(wt_SDL->renderer);
              }
      
      
              if(input->BOUTTON_B == 1)
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,128,128,0);
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleB);
                  SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TRBtext, NULL, &wt_SDL->rectangleB);
                  SDL_RenderPresent(wt_SDL->renderer);
              }
              else
              {
                  SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255);
                  SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->rectangleB);
                  SDL_RenderPresent(wt_SDL->renderer);
              }
      
              //JGX
              sprintf(input->JGXX, "X %d",input->JGX);
              SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
      
              SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy12);
              wt_SDL->SJoy12 = TTF_RenderText_Solid(wt_SDL->police,input->JGXX,wt_SDL->couleurRouge);
              wt_SDL->TJoy12 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy12);
              SDL_QueryTexture(wt_SDL->TJoy12, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy12, NULL, &wt_SDL->Joy12);
      
              //JGY JGYY
              sprintf(input->JGYY, "Y %d",input->JGY);
              SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
      
              SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy13);
              wt_SDL->SJoy13 = TTF_RenderText_Solid(wt_SDL->police,input->JGYY,wt_SDL->couleurRouge);
              wt_SDL->TJoy13 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy13);
              SDL_QueryTexture(wt_SDL->TJoy13, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy13, NULL, &wt_SDL->Joy13);
      
              //JDX JDXX
              sprintf(input->JDXX, "X %d",input->JDX);
              SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
      
              SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy22);
              wt_SDL->SJoy22 = TTF_RenderText_Solid(wt_SDL->police,input->JDXX,wt_SDL->couleurRouge);
              wt_SDL->TJoy22 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy22);
              SDL_QueryTexture(wt_SDL->TJoy22, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy22, NULL, &wt_SDL->Joy22);
      
              //JDY JDYY
              sprintf(input->JDYY, "Y %d",input->JDY);
              SDL_SetRenderDrawColor(wt_SDL->renderer,255,255,255,255); //BLANC
      
              SDL_RenderFillRect(wt_SDL->renderer, &wt_SDL->Joy23);
              wt_SDL->SJoy23 = TTF_RenderText_Solid(wt_SDL->police,input->JDYY,wt_SDL->couleurRouge);
              wt_SDL->TJoy23 = SDL_CreateTextureFromSurface(wt_SDL->renderer, wt_SDL->SJoy23);
              SDL_QueryTexture(wt_SDL->TJoy23, NULL, NULL, &w, &h);
              SDL_RenderCopy(wt_SDL->renderer, wt_SDL->TJoy23, NULL, &wt_SDL->Joy23);
      
              SDL_RenderPresent(wt_SDL->renderer);
      
              SDL_DestroyTexture(wt_SDL->TJoy23);
              SDL_DestroyTexture(wt_SDL->TJoy22);
              SDL_DestroyTexture(wt_SDL->TJoy13);
              SDL_DestroyTexture(wt_SDL->TJoy12);
      
      
              SDL_FreeSurface(wt_SDL->SJoy23);
              SDL_FreeSurface(wt_SDL->SJoy22);
              SDL_FreeSurface(wt_SDL->SJoy13);
              SDL_FreeSurface(wt_SDL->SJoy12);
      }
      


      fonction.h
      #include <stdio.h>
      #include <string.h>
      #include <stdlib.h>
      #include <math.h>
      #include <winsock2.h>
      #include <SDL2/SDL.h>
      #include <SDL2/SDL_ttf.h>
      
      #define WINDOW_W 1200
      #define WINDOW_H 1000
      #define PRECISION 0.001
      #define PI 3.14159265
      
      FILE* fichierLog;
      
      //Structure qui gere les evenements joystick, clavier
      typedef struct Input Input;
      struct Input
      {
          SDL_Joystick* joystick;
          int quitter ;
          int quittermode ;
      
          char data[200];
          char JGXX[10];
          char JGYY[10];
          char JDXX[10];
          char JDYY[10];
      
          int JGX_Max ; //calibration
          int JGY_Max ; //calibration
          int JDX_Max ; //calibration
          int JDY_Max ; //calibration
      
          int JGX_Mx ;
          int JGY_Mx ;
          int JDX_Mx ;
          int JDY_Mx ;
      
          int JGX ; //1
          int JGY ; //2
          int JDX ; //3
          int JDY ; //4
          int BOUTTON_A; //5- 0 Pour Boutton Relacher
          int BOUTTON_B ;//6
          int BOUTTON_Y ;//7
          int BOUTTON_X ;//8
          int BOUTTON_LB ; //9 boutton Gauche
          int BOUTTON_RB ; //10 boutton droite
          int BOUTTON_START ;//11
          int BOUTTON_BACK ; //12
          //Zone morte
          int DEADZONE_N ;
          int DEADZONE_P;
      
          //Mode de pilotage
          int mode_pilotage;
      };
      
      typedef struct wt_SDL wt_SDL;
      struct wt_SDL
      {
          //Fenetre principale et Render
          SDL_Window *screen;
          SDL_Renderer *renderer;
      
          SDL_Rect test;
          SDL_Surface *Stest;
          SDL_Texture *Ttest;
      
          SDL_Rect RTITRE;
          SDL_Surface *STITRE;
          SDL_Texture *TTITRE;
      
          SDL_Rect calibrer;
          SDL_Surface *Scalibrer;
          SDL_Texture *Tcalibrer;
      
              SDL_Rect cal_titre;
              SDL_Surface *Scal_titre;
              SDL_Texture *Tcal_titre;
      
      
          //Partie commande (haut)
          SDL_Rect rectangle1;
              SDL_Rect rectangleMID, rectangleA, rectangleY, rectangleX, rectangleB, Joy1 , Joy11, Joy12, Joy13, Joy2, Joy21, Joy22, Joy23  ;
              SDL_Surface *RAtext, *RYtext, *RXtext , *RBtext, *SJoy1, *SJoy11, *SJoy12, *SJoy13, *SJoy2, *SJoy21, *SJoy22, *SJoy23;
              SDL_Texture *TRAtext, *TRYtext, *TRXtext , *TRBtext, *TJoy1, *TJoy11, *TJoy12, *TJoy13, *TJoy2, *TJoy21, *TJoy22, *TJoy23;
      
              //Colonne gauche
              SDL_Rect case1, case2, case3, case4, case5, case6;
                  SDL_Surface *Scase1, *Scase2, *Scase3, *Scase4, *Scase5, *Scase6;
                  SDL_Texture *Tcase1, *Tcase2, *Tcase3, *Tcase4, *Tcase5, *Tcase6;
      
      
          //Partie Camera
          SDL_Rect rectangleCAM;
      
              //SDL_Texture
              SDL_Surface *Image; //Surface pour image de fond
              SDL_Texture *Image_fond; // image de fond
      
      
      
          //TTF
          SDL_Color couleurNoire;
          SDL_Color couleurRouge;
          SDL_Color couleurBlanche;
          TTF_Font *police;
      
      };
      
      
      //Declaration des fonctions
      
      void initialisation(const char *titre,wt_SDL *wt_SDL);
      
      void RAZ_input(Input *input);
      void RAZ_wt_SDL(wt_SDL *wt_SDL);
      
      void ArrierePlan(Input *input, wt_SDL *wt_SDL);
      void ArrierePlan_TTF(Input *input, wt_SDL *wt_SDL);
      
      void cleanup(wt_SDL *wt_SDL);
      void updateEvent(Input *input);
      
      void modepilotage1(Input *input, wt_SDL *wt_SDL);
      void modepilotage1(Input *input, wt_SDL *wt_SDL);
      
      
      
      0
  5. Vous n’avez pas trouvé la réponse que vous recherchez ?

    Posez votre question