SDL2, Code::block, gestion evenement, creation de surface [Résolu/Fermé]

Signaler
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
5432
Date d'inscription
mercredi 15 septembre 2004
Statut
Contributeur
Dernière intervention
15 octobre 2020
908
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
Merci

Quelques mots de remerciements seront grandement appréciés. Ajouter un commentaire

CCM 60511 internautes nous ont dit merci ce mois-ci

Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
21
Je viens de faire un test, plus je laisse tourner longtemps le programme, plus la consomation de memoire augmente
Je demarre je suis à ~40 000 Ko --- 30s + tard -- ~430 000K

Ya un probleme là ?
Messages postés
5432
Date d'inscription
mercredi 15 septembre 2004
Statut
Contributeur
Dernière intervention
15 octobre 2020
908
Tu as visiblement des fuites mémoire.

Cela peut arriver si :

- tu fais plusieurs malloc sur une seule variable pointeur, en écrasant l'ancien pointeur, rendant impossible la libération de mémoire sur le pointeur écrasé
- tu fais des malloc dans une boucle et tu ne libères jamais la mémoire avec free
- ...

Il faut traquer chaque usage de malloc et vérifier qu'il y a bien un free correspondant pour chaque malloc effectué. Parfois, il faut faire des allocations et libérations dans l'ordre : lorsque certains pointeurs permettent d'accéder à d'autres, tu ne dois pas libérer la mémoire pointée par les premiers pointeurs, tant que les seconds qui en dépendent n'ont pas été libérés, etc.

Il y a des outils qui permettent d'assister dans la recherche de fuites mémoires.

Sous Windows, la majorité des produits sont commerciaux, mais j'ai utilisé par le passé avec succès mss : http://libmss.sourceforge.net/ (plus maintenu à l'heure actuelle, mais fonctionne bien, open source et assez facile à utiliser).

Sous Linux, valgrind est l'outil de référence pour faire cela (et d'autres choses).

Dans ton cas, c'est probablement inutile de se donner la peine d'installer ces outils, ton problème doit se situer dans une boucle.

Une chose me chiffonne tout de même, car si tu n'as qu'un seul affichage à gérer (un seul écran), je ne vois pas très bien pourquoi tu devrais faire une allocation dynamique.

Rien ne t'interdit de le faire, bien sûr, mais pour allouer une seule struct Affichage, c'est un peu une usine à gaz, à moins que tu fasses des choses particulières que je ne saisis pas nécessitant de créer plusieurs struct Affichage.

Sinon, tu dis :

Donc en faite si je déclare une structure contenant uniquement des variables, il n'est pas nécessaire d'alloué de la memoire

Oui, la mémoire est allouée lorsque tu déclares tes variables.

par contre quand la structure contien des pointeurs vers des fonctions tel que SDL_rect etc, comme tu viens de me montrer, ont doit alloué la memoire.


D'abord une clarification (1), puis une correction sur ce que tu dis (2).

(1)

Lorsque tu déclares un pointeur, ce qui est alloué, c'est seulement l'espace mémoire pour la variable pointeur, c'est à dire l'espace nécessaire au stockage d'une adresse mémoire (quelques octets selon ton architecture).

A la déclaration de la variable pointeur, cette variable ne contient pas une adresse mémoire valide. Il va falloir demander au système de réserver de la mémoire, et obtenir l'adresse de cet espace que l'on pourra affecter à la variable pointeur.

Une fois que c'est fait, le pointeur permet, grâce à la variable pointeur, d'accéder de façon indirecte à l'espace mémoire pointé, pour manipuler les données.

Pour allouer cet espace et obtenir une adresse à mettre dans la variable pointeur, il faut utiliser malloc, ou une fonction toute faite (utilisant elle-même malloc) allouant cet espace pour toi et retournant un pointeur.

(2)

pointeurs vers des fonctions tel que SDL_rect

SDL_rect n'est pas une fonction, c'est une struct : https://wiki.libsdl.org/SDL_Rect. La SDL ne t'assiste pas spécialement pour réserver des espaces mémoire pour des pointeurs sur SDL_rect. C'est donc à toi de le faire avec malloc.

Il y a des fonctions SDL qui, en revanche, gèrent l'allocation de mémoire et renvoient un pointeur utilisable. C'est le cas de SDL_CreateTexture (https://wiki.libsdl.org/SDL_CreateTexture), qui renvoie un pointeur sur SDL_Texture, qui est elle-même une struct (https://wiki.libsdl.org/SDL_Texture). Lorsque tu utilises ce type de fonctions, tu n'as pas besoin d'utiliser malloc pour allouer l'espace pour la struct, car la SDL s'occupe de l'allocation.

C'est la documentation de la SDL qui le dit.

Lis la doc :-)


Dal
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
21
Ok je te remercie, j'ai bien compris, je vais travailler sur les pointeur et l'allocation de mémoire.

Une image de ce que je souhaite faire, cela te donnera une idee.
https://imgur.com/696z7mm
Les boutton A,B,X,Y change de couleur lorsqu'il y a un evenement

Joystick Gauche et droit, je veux y mettre une ligne qui demare a x0, y0 -> jusqu"a la position des joysticks, et en plus j'afficherai les cordonner en chiffre de chaque joystick

Cela me servira a verifier que mes joysticks fonctionnent correctement.
Messages postés
419
Date d'inscription
vendredi 28 mars 2014
Statut
Membre
Dernière intervention
25 décembre 2019
21
Par contre :

Je dessine mes rectangles en les déclarant comme variables globales, et je demare ma fonction avant ma boucle principale, le changement de couleur de mes rectangle correspondant à mes touche A B X Y, je le fais dans la gestion evenement joystick, a chaque boutton je fais ca


 if (e.type == SDL_JOYBUTTONDOWN) //ICI on gere les bouttons BOUTTON APPUYER
{
if (e.jbutton.button == 12)
                {
                    input->BOUTTON_X = 1;
                    SDL_SetRenderDrawColor(renderer,0,0,255,0); //BLEU
                    SDL_RenderFillRect(renderer, &rectangleX);
                    SDL_RenderPresent(renderer);
                }
SDL_SetRenderDrawColor(renderer,255,255,255,255); //BLEU
    SDL_RenderFillRect(renderer, &rectangleX);
}
else if (e.type == SDL_JOYBUTTONUP) //boutton relacher
{
if (e.jbutton.button == 12)
                {
                    input->BOUTTON_X = 0;
                    SDL_SetRenderDrawColor(renderer,255,255,255,255); //BLANC
                    SDL_RenderFillRect(renderer, &rectangleX);
                    SDL_RenderPresent(renderer);
                }
}


Alors au niveau du programme, comment ca se passe, a chaque fois que j'appuie sur un boutton, j'ajoute une nouvel couche de couleur ou ca efface la couleur precedente ?
A aucun moment j'utilise
SDL_RenderClear ()
sauf apres la creation de la fenetre pour mettre ma couleur de fond.

Et du coup, je me demande si c'est nessaire d'utiliser malloc() pour mon cas ?
Messages postés
5432
Date d'inscription
mercredi 15 septembre 2004
Statut
Contributeur
Dernière intervention
15 octobre 2020
908
Si tu as un seul affichage à gérer et un ensemble de zones statiques dont le nombre de varie pas, je ne vois pas l'intérêt de les allouer dynamiquement.

La question de savoir si tu en fais des variables globales ou pas est séparée.

Tu peux les déclarer dans main(), ou dans une fonction ad hoc, regroupées dans une struct, et passer en paramètre de tes fonctions un pointeur sur la struct.

De cette façon :

- l'allocation est automatique, et tu n'as pas à gérer malloc / free
- tu ne fais pas de variables globales
- tu ne copies pas non plus les données en les passant aux fonctions, mais tu passes seulement un pointeur vers la struct, ce qui accélère l'exécution des fonctions et réduit l'espace utilisé sur la pile


Dal
Messages postés
5432
Date d'inscription
mercredi 15 septembre 2004
Statut
Contributeur
Dernière intervention
15 octobre 2020
908
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
Merci

Quelques mots de remerciements seront grandement appréciés. Ajouter un commentaire

CCM 60511 internautes nous ont dit merci ce mois-ci

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