LicenceInfoLyon1

SDL (Simple DirectMedia Layer) est une bibliothèque en C qui permet de créer des fenêtres, gérer des graphismes, des sons et des événements clavier/souris. Elle est utilisée dans cette UE pour créer une interface graphique dans des projets comme des jeux, des simulations ou des visualisations.

La prise en main est un peu rude : entre la compilation, l’initialisation des fenêtres, la gestion des événements... y a de quoi se perdre 😅.

// Initialisation typique
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
    printf(\"Erreur SDL_Init : %s\\n\", SDL_GetError());
    return 1;
}

SDL_Window* win = SDL_CreateWindow(\"Ma fenêtre\", 100, 100, 640, 480, SDL_WINDOW_SHOWN);

On combine ensuite une boucle de rendu (affichage) avec une gestion des événements, un peu comme une boucle de jeu.

Dans cette UE, on met aussi l’accent sur la modularité : séparer le code en fichiers `.h` / `.cpp`, créer des structures de données claires (struct, classes), et avoir une architecture propre.

• Un fichier pour la gestion graphique (SDL)
• Un fichier pour la logique (moteur du jeu ou simulation)
• Un fichier principal `main.cpp`

Par exemple, on peut avoir un fichier `graphique.h` pour les fonctions liées à SDL, et un fichier `logique.h` pour la logique de l’application. Cela permet de mieux s’y retrouver et de faciliter la maintenance du code.

On peut aussi utiliser des classes pour encapsuler la logique et la gestion graphique, mais attention à ne pas trop complexifier le code. L’idée est de garder une structure claire et lisible.

Voici un exemple de structure de projet :

mon_projet/
├── main.cpp
├── graphique.h
├── graphique.cpp
├── logique.h
├── logique.cpp
└── ressources  

Dans `main.cpp`, on inclut les fichiers d’en-tête et on appelle les fonctions de gestion graphique et logique.

#include \"graphique.h\"
#include \"logique.h\"
int main(int argc, char* argv[]) {
    // Initialisation de SDL
    if (SDL_Init(SDL_INIT_VIDEO) != 0) {
        printf(\"Erreur SDL_Init : %s\\n\", SDL_GetError());
        return 1;
    }

    // Création de la fenêtre
    SDL_Window* win = SDL_CreateWindow(\"Ma fenêtre\", 100, 100, 640, 480, SDL_WINDOW_SHOWN);
    if (!win) {
        printf(\"Erreur SDL_CreateWindow : %s\\n\", SDL_GetError());
        return 1;
    }

    // Boucle principale
    while (1) {
        // Gestion des événements
        gerer_evenements();
        
        // Logique de l'application
        mettre_a_jour_logique();

        // Affichage
        afficher_graphique();
    }

    // Nettoyage
    SDL_DestroyWindow(win);
    SDL_Quit();
}

Dans `graphique.h`, on peut définir les fonctions de gestion graphique :

void afficher_graphique();
void gerer_evenements();
void initialiser_graphique();
void nettoyer_graphique();

Et dans `logique.h`, on peut définir les fonctions de logique :

void mettre_a_jour_logique();
void initialiser_logique();
void nettoyer_logique();

Cela permet de garder le code organisé et de faciliter la compréhension.

En résumé, l’important est de bien structurer son code, de séparer la logique et la gestion graphique, et de garder une architecture claire. Cela facilitera la maintenance et la compréhension du code, surtout dans des projets plus complexes.

N’hésite pas à utiliser des commentaires pour expliquer ton code, même si tu es le seul à le lire. Ça peut t’aider à te souvenir de ce que tu as fait et pourquoi.

Je te met a disposition quelques les projets que j’ai réalisés dans cette UE.

Ils ne sont pas parfaits, mais ils peuvent te donner une idée de la structure et de l’organisation du code. Tu peux les utiliser comme base pour tes propres projets ou pour t’inspirer.

• Module image
• Projet RiseOfSerpentard (un Snake particulier)

• Teste chaque étape indépendamment (ex : d’abord créer une fenêtre, ensuite gérer un événement, etc.)
• Commente ton code au fur et à mesure, même pour toi-même
• Garde un projet minimal fonctionnel et ajoute petit à petit
• Regarde des petits tutos SDL en ligne : parfois 5 minutes vidéo valent 1h de docs