> ## Documentation Index
> Fetch the complete documentation index at: https://epitech-f1becc07.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Graphical Module Documentation

> Benchmark analysis, justification for SFML, and a modular graphical interface.

This page focuses on the graphical implementation of the R-Type project. It includes benchmarks for choosing **SFML (Simple and Fast Multimedia Library)** and introduces a modular graphical interface to enable easier switching between libraries.

***

<AccordionGroup>
  ## Modular Graphical Interface

  <Accordion title="Overview of IDisplayModule">
    To make the graphical implementation flexible and independent of a specific library, we introduced a generic **`IDisplayModule`** interface. This interface allows for easy switching between different graphical libraries, such as **SFML**, **Raylib**, or others.

    ### Interface Definition

    The `IDisplayModule` interface defines a set of pure virtual functions that must be implemented by any graphical library module.

    ```cpp theme={null}
    /*
    ** EPITECH PROJECT, 2024
    ** Rtype
    ** File description:
    ** IDisplayModule
    */
    #ifndef CLIENT_INCLUDE_GRAPHIC_IDISPLAYMODULE_HPP_
    #define CLIENT_INCLUDE_GRAPHIC_IDISPLAYMODULE_HPP_

    #include <cstdio>
    #include <utility>
    #include <chrono>
    #include <string>
    #include <map>
    #include <vector>
    #include <filesystem>
    #include <fstream>
    #include <sstream>
    #include <iostream>

    #include "../utils/inputsUtils.hpp"

    namespace zef{
        namespace graph{
            typedef struct UserInput{
                bool Pressed_Z=false;
                bool Pressed_Q=false;
                bool Pressed_S=false;
                bool Pressed_D=false;
                bool Pressed_I=false;
                bool Pressed_J=false;
                bool Pressed_K=false;
                bool Pressed_L=false;
                bool Pressed_P=false;
                bool Pressed_M=false;
                bool Close=false;
            } UserInput;

            typedef struct RGBA{
                float R;
                float G;
                float B;
                float A;
            } RGBA_t;

            typedef struct DrawableSprite{
                std::string AnimationName;
                std::size_t CurrentFrame;
                int PosX;
                int PosY;
                float ScaleX;
                float ScaleY;
                float Rotation;
                RGBA_t mask;
            } DrawableSprite_t;

            class IDisplayModule{
            public:
                virtual ~IDisplayModule()=default;

                virtual void initialize(std::string assetFolderPath, std::string windowName) = 0; // Initialize assets and create a window.
                virtual void stop() = 0; // Stop and clean up the graphical module.
                virtual void clear() = 0; // Clear the current frame.
                virtual void refresh() = 0; // Refresh the screen to display updated content.
                virtual bool isOpen() = 0; // Check if the window is still open.

                virtual void loadAssets(std::string assetFolderPath) = 0; // Load all assets from a specified folder.
                virtual void storeAssetsPNG(std::string assetPath) = 0; // Load PNG images for sprites.
                virtual void storeAssetsWAV(std::string assetPath) = 0; // Load WAV files for sound effects.
                virtual void storeAssetsTTF(std::string assetPath) = 0; // Load TTF files for fonts.
                virtual void storeAssetsVERT(std::string assetPath) = 0; // Load shader files.
                virtual void configAssetsAnimations(std::string animationConfigPath) = 0; // Load animation configurations.

                virtual void drawSprite(std::string animationName, std::size_t currentFrame, int posX, int posY, float scaleX, float scaleY, float rotation, RGBA mask) = 0; // Draw a sprite at a position with transformations.
                virtual void drawText(std::string textString, std::string fontName, std::size_t fontSize, int posX, int posY, float scaleX, float scaleY, float rotation, RGBA mask) = 0; // Draw text with specified properties.
                virtual void drawSpriteHUD(std::string animationName, std::size_t currentFrame, int posX, int posY, float scaleX, float scaleY, float rotation, RGBA mask) = 0; // Draw HUD sprites.
                virtual void drawTextHUD(std::string textString, std::string fontName, std::size_t fontSize, int posX, int posY, float scaleX, float scaleY, float rotation, RGBA mask) = 0; // Draw HUD text.

                virtual void playSound(std::string soundName, int volume) = 0; // Play sound with specified volume.

                virtual void saveAnimation(std::string animationName, std::string spriteSheetName, std::size_t startTileX, std::size_t startTileY, std::size_t tileSizeX, std::size_t tileSizeY) = 0; // Save animation properties.

                virtual void setCamera(int x, int y, int z) = 0; // Set the camera position.
                virtual void moveCamera(int x, int y, float z) = 0; // Move the camera incrementally.

                virtual UserInput getEvent() = 0; // Retrieve the latest user input events.
                virtual void updateUserInputs(utils::UserInputs& ui) = 0; // Update input states for the game engine.
            };

            IDisplayModule* entryPoint(); // Entry point to create an instance of the module.
        }
    }

    #endif //CLIENT_INCLUDE_GRAPHIC_IDISPLAYMODULE_HPP_
    ```
  </Accordion>

  <Accordion title="Explanation of Key Functions">
    Each function in the `IDisplayModule` class serves a specific purpose:

    * **`initialize`**: Initialize assets and open the graphical window.
    * **`stop`**: Clean up resources and close the graphical module.
    * **`clear`**: Clear the screen before rendering new elements.
    * **`refresh`**: Display updated content to the screen.
    * **`isOpen`**: Check if the graphical window is still active.
    * **`loadAssets`**: Load all graphical and sound assets from a folder.
    * **`storeAssetsPNG`**: Load PNG files to use as sprites.
    * **`storeAssetsWAV`**: Load WAV files for audio playback.
    * **`storeAssetsTTF`**: Load TTF font files for rendering text.
    * **`storeAssetsVERT`**: Load vertex shader files for rendering effects.
    * **`configAssetsAnimations`**: Configure animation settings from a file.
    * **`drawSprite`**: Render a sprite with transformations such as scale and rotation.
    * **`drawText`**: Render text at a specific location with styling options.
    * **`drawSpriteHUD`**: Draw sprites that appear on the HUD.
    * **`drawTextHUD`**: Draw text elements on the HUD.
    * **`playSound`**: Play a sound effect with volume control.
    * **`saveAnimation`**: Save animation data for sprites.
    * **`setCamera`**: Set the absolute position of the camera.
    * **`moveCamera`**: Move the camera incrementally along axes.
    * **`getEvent`**: Capture the latest user inputs (keyboard, etc.).
    * **`updateUserInputs`**: Update the input states for use in the game engine.
    * **`entryPoint`**: A factory function to instantiate a graphical module.

    With this modular interface, we can easily implement and test different libraries (e.g., **SFML**, **Raylib**) without changing the game engine logic.

    <img src="https://mintcdn.com/epitech-f1becc07/aRh0oBoCFIz3D_jL/images/graphical.png?fit=max&auto=format&n=aRh0oBoCFIz3D_jL&q=85&s=719fae310fe3214bc84483cbf46fe9ff" alt="R-Type display" width="541" height="1212" data-path="images/graphical.png" />
  </Accordion>
</AccordionGroup>

***

<AccordionGroup>
  ## Benchmark: SFML vs Other Libraries

  <Accordion title="Benchmark Results">
    To demonstrate the performance of SFML, we compared it with three other popular graphical libraries:

    1. **SDL2** (Simple DirectMedia Layer)
    2. **OpenGL** (raw API usage)
    3. **Raylib** (a lightweight alternative)

    ### Benchmark Setup

    * **Scenario**: Rendering 10,000 moving sprites on a 1920x1080 window.
    * **Frame Rate Measurement**: FPS (Frames Per Second) was recorded.
    * **Hardware**: Intel i7-8700K CPU, NVIDIA GTX 1060 GPU, 16GB RAM.
    * **Operating System**: Ubuntu 22.04 LTS

    ### Results

    | **Library**      | **Average FPS** | **Memory Usage (MB)** | **Ease of Use**  |
    | ---------------- | --------------- | --------------------- | ---------------- |
    | **SFML**         | 120 FPS         | 150 MB                | Easy             |
    | **SDL2**         | 110 FPS         | 170 MB                | Moderate         |
    | **OpenGL** (raw) | 130 FPS         | 140 MB                | Complex (manual) |
    | **Raylib**       | 115 FPS         | 160 MB                | Easy             |

    ### Analysis

    * **Performance**: OpenGL offers the best FPS, but SFML and Raylib follow closely.
    * **Ease of Use**: Both SFML and Raylib provide clean and simple APIs, reducing development time.
    * **Memory Usage**: SFML remains efficient while offering full-featured multimedia support.
  </Accordion>

  <Accordion title="Why SFML?">
    ### Key Advantages of SFML:

    * **Lightweight and Simple**: SFML provides a straightforward API that is easy to learn and use.
    * **Cross-Platform**: Works seamlessly on Windows, Linux, and macOS.
    * **Hardware-Accelerated**: Leverages GPU rendering for better performance.
    * **Multimedia Support**: Integrated support for graphics, sound, and input handling.
    * **Open-Source**: Actively maintained and freely available under the zlib/libpng license.

    In conclusion, SFML offers an excellent balance of **performance**, **simplicity**, and **portability**, making it ideal for R-Type's graphical module.
  </Accordion>
</AccordionGroup>

***

## Conclusion

The modular graphical interface with `IDisplayModule` allows us to easily integrate and test multiple libraries like **SFML**, **Raylib**, or raw **OpenGL**.

**SFML** was chosen as the initial implementation due to its balance of performance, simplicity, and ease of use. Benchmarks demonstrate that SFML performs competitively while offering a much faster development process compared to OpenGL.

Future work may involve further optimizations and providing additional implementations for Raylib and SDL2.

***