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.

---

Modular Graphical Interface

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.

/*
** 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_

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.

---

Benchmark: SFML vs Other Libraries

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.

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.

---

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.

---