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

Résolu/Fermé
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
-
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
-
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

Messages postés
5733
Date d'inscription
mercredi 15 septembre 2004
Statut
Contributeur
Dernière intervention
28 janvier 2022
966
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
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
28
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
Messages postés
5733
Date d'inscription
mercredi 15 septembre 2004
Statut
Contributeur
Dernière intervention
28 janvier 2022
966
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
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
28
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() ?
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
28
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!
Messages postés
5733
Date d'inscription
mercredi 15 septembre 2004
Statut
Contributeur
Dernière intervention
28 janvier 2022
966
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
Messages postés
5733
Date d'inscription
mercredi 15 septembre 2004
Statut
Contributeur
Dernière intervention
28 janvier 2022
966
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
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
28
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.
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
28
Par contre ligne 89, c'est quoi l'utilité de
getchar();
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
28
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<------
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
28
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 ^^
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
28
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);
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
28
J'AI REUSSI !!! Maintenant je passe au reseau !!
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
28
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.
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
28
La suite dans un future topic
MERCI
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
28
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);


Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
28
µBonjour Dal voudrais -tu m'aider sur l'utilisation des sockets, j'ai du mal a comprendre ..

Sur ce topic:
https://forums.commentcamarche.net/forum/affich-33427963-client-serveur-utilisation-des-sockets#p33430485