feat!: rewrote program in a data oriented style.

This is because the source code is objected oriented which is not cpu cache
friendly, making the program slower than it has to be. Yuzu's entire
codebase is written in a objected oriented way and I wonder how much faster
it could if they had use DoD principles from the very beginning.

That's why I want to instill DoD fundamentals early on so this won't be a
problem going forward.

Signed-off-by: Ronald Caesar <github43132@proton.me>

gui/gui.h

@@ -0,0 +1,219 @@
+#ifndef POUND_GUI_H
+#define POUND_GUI_H
+
+#include <SDL3/SDL.h>
+#include <vector>
+#include "memory/arena.h"
+
+namespace gui
+{
+
+#define WINDOW_MINIMUM_SIZE_WIDTH 640
+#define WINDOW_MINIMUM_SIZE_HEIGHT 480
+
+#define GUI_SUCCESS 0
+#define WINDOW_SHOULD_CLOSE 1
+#define ERROR_OPENGL 2
+
+/*
+ *  NAME
+ *      window_t - Structure representing a window with OpenGL context.
+ *
+ *  SYNOPSIS
+ *      #include "gui/gui.h"
+ *
+ *      typedef struct {
+ *          SDL_Window* data;               // Window created by the SDL library.
+ *          SDL_GLContext gl_context;       // OpenGL context associated with the window.
+ *      } window_t;
+ *
+ *  DESCRIPTION
+ *      The window_t structure is used to represent a window along with its associated OpenGL context.
+ *
+ *  EXAMPLE
+ *
+ *  #include "gui/gui.h"
+ *  #include <stdio.h>
+ *
+ *  int main() {
+ *      gui::window_t window;
+ *
+ *      // Initialize the widow.
+ *      if (!gui::window_init(&window, "Pound Emulator", 800, 600)) {
+ *          fprintf(stderr, "Failed to initialize the window. \n");
+ *          return -1;
+ *      }
+ *
+ *      // Clean up when done.
+ *      gui::window_destroy(&window);
+ *  }
+ */
+typedef struct
+{
+    SDL_Window* data;
+    SDL_GLContext gl_context;
+} window_t;
+
+/*
+ *  NAME
+ *      window_init - Initializes a window with specified properties.
+ *
+ *  SYNOPSIS
+ *      #include "gui/gui"
+ *
+ *      bool gui::window_init(window_t* window, const char*  title, int64_t width, int64_t height);
+ *
+ *  DESCRIPTION
+ *      The function initializes a window with the given parameters.
+ *
+ *  RETURN VALUE
+ *      The function returns true if the window successfully initialized with all properties set, false otherwise.
+ *
+ *  NOTES
+ *      - Ensure that the window is not null before calling this function.
+ *      - The window will be created with OpenGL support.
+ */
+bool window_init(window_t* window, const char* title, int64_t width, int64_t height);
+
+/*
+ *  NAME
+ *      window_destroy - Destroys a previously initialized window and its associated OpenGL context.
+ *
+ *  SYNOPSIS
+ *      #include "gui/gui.h"
+ *
+ *      void gui::window_destroy(gui::window_t* window);
+ *
+ *  DESCRIPTION
+ *      The function cleans up resources associated with a previous initialized window.
+ *
+ *  NOTES
+ *      - Ensure that the window parameter is valid and points to a previous initialized window structure.
+ *      - It is essential to call this function for every window created with gui::window_init() to prevent resource leaks.
+ */
+void window_destroy(window_t* window);
+
+/*
+ *  NAME
+ *      gui_t - Structure representing the main GUI system with window and panel management.
+ *
+ *  SYNOPSIS
+ *      #include "gui/gui.h"
+ *
+ *      typedef struct {
+ *          window_t window;                  // Main window of the GUI with OpenGL context
+ *          const char** custom_panels;       // Array of pointers to custom panel names
+ *          bool* custom_panels_visibility;   // Array tracking visibility state of each panel
+ *          size_t custom_panels_capacity;    // Maximum number of panels that can be managed
+ *      } gui_t;
+ *
+ *  DESCRIPTION
+ *      The gui_t structure represents the core GUI system, managing the main window and any
+ *      additional user-defined panels. It provides a container for all resources needed to
+ *      maintain and render the graphical interface.
+ *
+ *      This structure should be initialized before use and destroyed when no longer needed to
+ *      properly manage memory and system resources.
+ *
+ *  EXAMPLE
+ *
+ *  #include "gui/gui.h"
+ *  #include <stdio.h>
+ *
+ *  int main() {
+ *      gui::gui_t gui;
+ *
+ *      // Initialize the GUI system
+ *      if (!gui::init(&gui, &main_window)) {
+ *          fprintf(stderr, "Failed to initialize the GUI. \n");
+ *          return -1;
+ *      }
+ *
+ *      // Use the GUI for rendering...
+ *      ...
+ *
+ *      // Clean up when done.
+ *      gui::destroy(&gui);
+ *  }
+ */
+typedef struct
+{
+    window_t window;
+    const char** custom_panels;
+    bool* custom_panels_visibility;
+    size_t custom_panels_capacity;
+} gui_t;
+
+/*
+ *  NAME
+ *      init_imgui - Initializes ImGui and its integration with SDL3 and OpenGL.
+ *
+ *  SYNOPSIS
+ *      #include "gui/gui.h"
+ *
+ *      bool gui::init_imgui(gui::window_t* main_window);
+ *
+ *  DESCRIPTION
+ *      This function initializes the ImGui library along with its integration with
+ *      SDL3 for input handling and OpenGL for rendering. It sets up all necessary
+ *      configurations and context required for ImGui to work properly.
+ *
+ *  RETURN VALUE
+ *      Returns true if ImGui initialization was successful, false otherwise.
+ *
+ *  NOTES
+ *      - The function assumes that the main window has already been created and initialized
+ *      - This should be called before any other ImGui functions are used
+ */
+bool init_imgui(gui::window_t* main_window);
+
+/*
+ *  NAME
+ *      render_memu_bar - Renders a main menu bar with standard menus and custom panels.
+ *
+ *  SYNOPSIS
+ *      #include "gui/gui.h"
+ *
+ *      int8_t gui::render_memu_bar(const char** panels, const size_t panels_count,
+ *                                 bool* panels_visibility, bool* imgui_demo_visible);
+ *
+ *  DESCRIPTION
+ *      This function renders a main menu bar using ImGui that includes standard menus like File and View.
+ *
+ *      The File menu contains an Exit option that triggers window closure.
+ *      The View menu displays all custom panels registered with their visibility toggles,
+ *      plus an optional ImGui demo window toggle.
+ *
+ *  PARAMETERS
+ *      panels - Array of panel names to be displayed in the View menu
+ *      panels_count - Number of panels in the array
+ *      panels_visibility - Boolean array indicating current visibility state for each panel
+ *      imgui_demo_visible - Pointer to boolean controlling visibility of ImGui demo window
+ *
+ *  RETURN VALUE
+ *      Returns one of these codes:
+ *          GUI_SUCCESS - Normal operation
+ *          WINDOW_SHOULD_CLOSE - Exit option was selected
+ *
+ *  NOTES
+ *      - Panel visibility state is toggled when corresponding menu items are clicked
+ */
+int8_t render_memu_bar(const char** panels, size_t panels_count, bool* panels_visibility, bool* imgui_demo_visible);
+
+/*
+ *  NAME
+ *      destroy - Destroys a GUI system and cleans up resources.
+ *
+ *  SYNOPSIS
+ *      #include "gui/gui.h"
+ *
+ *      void gui::destroy();
+ *
+ *  DESCRIPTION
+ *      The function cleans up and releases all resources associated with the GUI system.
+ */
+void destroy();
+
+}  // namespace gui
+
+#endif  //POUND_GUI_H