#include  "SDL.h"             // Bibliothèque de base SDL (fonctionnalité fenêtre/rendu, saisie, chronomètre...)
#include  "SDL_opengl.h"      // Fonctionnalité SDL OpenGL (si nécessaire, au lieu du moteur de rendu interne)

#include  "SDL_image.h"       // Fonctionnalité de chargement d'image (dans SDL_Surface)
#include  "SDL_ttf.h"         // Chargement et rastérisation des données de police (dans l'image) 
#include  "SDL_mixer.h"       // Gestion des périphériques audio et chargement des fichiers audio

#include  "raylib.h"          // inclusion de raylib (expose toutes les fonctionnalités de chaque module)

// Initialisation de l'état global interne de SDL 
// Note : SDL permet d'initialiser uniquement les sous-systèmes souhaités 
SDL_Init (SDL_INIT_EVERYTHING);

// Fenêtre d'initialisation 
SDL_Window *window = SDL_CreateWindow("Welcome to SDL!", 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, flags

// Initialisation du moteur de rendu 
SDL_Renderer *renderer = SDL_CreateRenderer(state.window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
SDL_SetRenderDrawColor(renderer, 100, 149, 237, 255);  // Default clear color: Cornflower blue

// Boucle d'application 
while (!closeWindow)
{

// Traiter les événements d'entrée

// Dessiner
}

// Désinitialise le moteur de rendu et la fenêtre
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);

// Désinitialise l'état global interne du SDL 
SDL_Quit();

// Fonctionnalité OpenGL requise 
#include  "SDL_opengl.h"

// Initialise l'état global interne du SDL 
SDL_Init (SDL_INIT_EVERYTHING);

// Fenêtre d'initialisation 
SDL_Window *window = SDL_CreateWindow("Bienvenue dans SDL OpenGL!", 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_OPENGL);

// Initialisation du contexte OpenGL 
SDL_GLContext glcontext = SDL_GL_CreateContext(window);
   
// Boucle d'application 
while (!closeWindow)
{
    // Traiter les événements d'entrée

    // Dessinez en utilisant OpenGL 
    // Note : C'est à l'utilisateur de charger les extensions requises et de gérer l'état OpenGL et le dessin 
    glClearColor(0,0,0,1);
    glClear(GL_COLOR_BUFFER_BIT);
    SDL_GL_SwapWindow(window);
}

// Désinitialise le contexte et la fenêtre OpenGL
SDL_GL_DeleteContext(glcontext);

// Désinitialise l'état global interne du SDL
SDL_Quit();

// Initialisation de l'état global interne de raylib et création de la fenêtre 
InitWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Bienvenue dans raylib!");

// Boucle d'application... 
while (!WindowShouldClose())
{
    // Dessine 
    BeginDrawing();
         ClearBackground(BLACK);
    
    // Les événements d'entrée sont traités en interne par défaut 
    EndDrawing();
}
    
// Désinitialise l'état global interne de raylib et la fenêtre 
CloseWindow();

// Initialisation de l'entrée manette 
// Vérifiez SDL_NumJoysticks() et SDL_JoystickOpen()
if (SDL_NumJoysticks() < 1) SDL_Log( "ATTENTION: aucune manette connectée!\n");
else
{
    SDL_Joystick *gamepad = SDL_JoystickOpen(0);
    if (SDL_Joystick * gamepad == NULL) SDL_Log("Alerte : Impossible ouvrir manette! Erreur SDL: %s\n", SDL_GetError());
}

// Événements d'entrée d'interrogation
SDL_Event event = { 0 };
SDL_PollEvent(&event);

// Tous les événements d'entrée peuvent être traités après le commutateur d'interrogation switch(event.type)
{
    case SDL_QUIT: closeWindow = true; break;

    // Les événements de fenêtre sont également interrogés (minimisé, maximisé, fermé...) 
    case SDL_WINDOWEVENT: break;
       
    // événements clavier
    case SDL_KEYDOWN:
    {
        if (event.key.keysym.sym == SDLK_ESCAPE) closeWindow = true;
    } break;
    
    // Vérification des événements souris
    case SDL_MOUSEBUTTONDOWN: break;
    case SDL_MOUSEBUTTONUP: break;
    case SDL_MOUSEWHEEL: break;
    case SDL_MOUSEMOTION:
    {
        mousePosition.x = event.motion.x;
        mousePosition.y = event.motion.y;
    } break;

    // Vérification des événements manette
    case SDL_JOYAXISMOTION:
    {
        // mouvement sur manette 0
        if (event.jaxis.which == 0)
        {
            // mouvement axe X
            if (event.jaxis.axis == 0)
            {
                //...
            }
            // mouvement axe Y
            else if (event.jaxis.axis == 1)
            {
                //...
            }
        }
    } break;
    default: break;
}

// L'interrogation des entrées est effectuée par défaut par EndDrawing() et les états sont gérés en interne (UP, DOWN)

// Vérification si une touche a été enfoncée (UP->DOWN) 
if (IsKeyPressed(KEY_ENTER)) currentScreen = SCREEN_GAMEPLAY;

// Vérification si une touche est enfoncée (DOWN)
if (IsKeyDown(KEY_LEFT)) player.position.x -= player.speed.x;
else if (IsKeyDown(KEY_RIGHT)) player.position.x += player.speed.x;

// Vérification si le bouton de la souris a été enfoncé et obtient la position de la souris
if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)
{
    Vector2 mousePosition = GetMousePosition();
}

// Vérification si le bouton de la manette est enfoncé 
if (IsGamepadButtonPressed(GAMEPAD_BUTTON_LEFT_FACE_RIGHT)) { }

// Récupération du mouvement de l'axe de la manette
float axisValue = GetGamepadAxisMovement(0, GAMEPAD_AXIS_RIGHT_TRIGGER);

// Définition du mélange et la couleur pour le dessin des formes
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);   // RED

// Dessin d'un rectangle rouge à la position (10, 10) de taille (200, 180)
SDL_Rect rec = { 10, 10, width, height };
SDL_RenderFillRect(renderer, &rec);

// Dessin d'un rectangle rouge à la position (10, 10) de taille (200, 180)
DrawRectangle(10, 10, 200, 180, RED );

// Fonctionnalité de chargement d'image requise 
#include "SDL_image.h"

// Initialisation du système d'images 
IMG_Init(IMG_INIT_PNG);

// Charge l'image et charge la texture à partir de celle-ci,
// notez que les types renvoyés sont en fait des pointeurs opaques
SDL_Surface *image = IMG_Load("sample.png");
SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, image);
SDL_FreeSurface(surface); // L'image peut être déchargée une fois chargée dans la texture

// Les propriétés de texture doivent être interrogées en raison des pointeurs opaques
int format, access, width, height;
SDL_QueryTexture(texture, &format, &access, &width, &height);

// Charge l'image et charge la texture à partir de cette image,
// notez que les types renvoyés sont des structures transparentes 
Image image = LoadImage("sample.png");
Texture2D texture = LoadTextureFromImage(image);
UnloadImage(image); // L'image peut être déchargée une fois chargée dans la texture

// Les données de texture sont directement accessibles : texture.width, texture.height, texture.format

// La texture peut être directement chargée à partir du fichier image,
// en fait, le processus interne est le même que celui de l'exemple précédent
Texture2D texture = LoadTexture("sample.png");

// Initialisation de la texture pour le rendu hors ligne
SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, 1024, 1024);

// Activation de la texture de rendu pour le dessin
SDL_SetRenderTarget(renderer, texture );

// Dessin d'un point dans la texture (définition du mélange et de la couleur)
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(renderer, 255, 0, 255, 255);
SDL_RenderDrawPoint(renderer, 123, 456);

// Activation de la fenêtre pour continuer à dessiner
SDL_SetRenderTarget(renderer, NULL );

// Chargement de la texture de rendu pour le rendu hors ligne
// Remarque : par défaut, un tampon de couleur RVBA 32 bits et un tampon de rendu de profondeur sont créés.
RenderTexture target = LoadRenderTexture(1024, 1024);

// Activation de la texture de rendu pour le dessin
BeginTextureMode(target);

// Dessin d'un point dans la texture
DrawPixel(123, 456, MAGENTA);

// Activation de la fenêtre pour continuer à dessiner
EndTextureMode();

// Fonctionnalité de chargement de police requise
#include <SDL_ttf.h>

// Initialise le système de polices
TTF_Init();

// Chargement de la police à partir du fichier
TTF_Font *font = TTF_OpenFont("arial.ttf", 24);

// Restitution du texte dans une surface en utilisant la police et la couleur fournies
SDL_Color color = { 255, 255, 255 };
SDL_Surface *surface = TTF_RenderText_Solid(font, "Bienvenue dans SDL", color);

// Création d'une texture à partir de la surface
SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, surface);

// Dessin d'une texture (contenant du texte)
int texWidth = 0, texHeight = 0;
SDL_QueryTexture(texture, NULL, NULL, &texWidth, &texHeight);
SDL_Rect dstrect = { 0, 0, texWidth, texHeight };

SDL_RenderCopy(renderer, texture, NULL, &dstrect);
SDL_RenderPresent(renderer);

// Déchargement de la texture (contenant du texte)
SDL_DestroyTexture(texture);
SDL_FreeSurface(surface);

// Déchargement de la police et ferme le système de polices
TTF_CloseFont(font);
TTF_Quit();

// Dessin du texte sur l'écran à la position (100, 200), hauteur 20 pixels, couleur ROUGE
DrawText("Bienvenue dans raylib", 100, 200, 20, RED);

// Chargement de la police à partir du fichier
// Remarque : raylib génère automatiquement un atlas de polices avec certains paramètres par défaut :
// 32 pixels de hauteur (taille), 95 caractères, 4 pixels de remplissage
// LoadFontEx() est également fourni pour un contrôle plus fin de la taille de la police et
// les points de code requis
Font font = LoadFont("arial.ttf");

// Dessin du texte à l'écran en utilisant la police chargée, le système de traitement par lots interne
// rend ce processus très efficace
DrawTextEx(font, "Bienvenue dans raylib", (Vector2){ 10.0f, 10.0f }, 20, 1, RED);

// Déchargement de la police
UnloadFont(font);

#include "SDL_mixer.h" // Gestion des périphériques audio et chargement des fichiers audio requis

// Initialisation du système audio
Mix_Init(MIX_INIT_OGG);
Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048);

// Chargement du fichier son (données audio complètes chargées en mémoire)
Mix_Chunk *sound = Mix_LoadWAV("Assets/sound.wav");

// Chargement du fichier musical (un seul morceau de données, destiné à la lecture en continu)
Mix_Music *music = Mix_LoadMUS("Assets/music.ogg");

// Joue le fichier son une fois
Mix_PlayChannel(-1, sound, 0);

// Commence à jouer de la musique en continu
Mix_PlayMusic(music, -1);

// Décharge les données sonores et musicales
Mix_FreeMusic(music);
Mix_FreeChunk(sound);

// Ferme le système audio
Mix_CloseAudio();
Mix_Quit();

// Initialisation du périphérique audio (configuration par défaut : 44100 Hz, deux canaux)
InitAudioDevice();

// Chargement du fichier son (données audio complètes chargées en mémoire)
Sound sound = LoadSound("Assets/sound.wav");

// Chargement du fichier musical (un seul morceau de données, destiné à la lecture en continu)
Music music = LoadMusicStream("Assets/music.ogg");

// Joue un fichier son une fois
PlaySound(sound);

// Commence à jouer de la musique en continu
PlayMusicStream(music);

// Remplissage des tampons du flux de musique s'ils sont déjà traités (doit être appelé par l'utilisateur)
UpdateMusicStream(music);

// Déchargement des données sonores et musicales
UnloadMusic(music);
UnloadSound(sound);

// Fermeture du périphérique audio
CloseAudioDevice();