.. _program_listing_file_gui_Demeter_Demeter.hpp:

Program Listing for File Demeter.hpp
====================================

|exhale_lsh| :ref:`Return to documentation for file <file_gui_Demeter_Demeter.hpp>` (``gui/Demeter/Demeter.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   #include <algorithm>
   #include <array>
   #include <memory>
   #include <optional>
   #include <unordered_map>
   #include <vector>
   
   #include "Renderer/Object3D.hpp"
   
   #include "Entity.hpp"
   
   namespace Dem {
   
     struct Demeter {
     private:
       std::unique_ptr<SDL2> sdl2;
   
       struct Time {
       private:
         Uint64 last;
         Uint64 current;
         double delta = 0;
   
       public:
         Time() = default;
   
         Time(const SDL2 &sdl2Instance)
           : last(sdl2Instance.GetTicks64()), current(last)
         {
         }
   
         void Update(const SDL2 &sdl2Instance);
   
         [[nodiscard]] Uint64 GetLast() const
         {
           return last;
         }
   
         [[nodiscard]] Uint64 GetCurrent() const
         {
           return current;
         }
   
         [[nodiscard]] double GetDelta() const
         {
           return delta;
         }
       } time;
   
       struct InputState {
         std::array<bool, SDL_NUM_SCANCODES> keys;
         int mouseX, mouseY;
         int mouseDeltaX, mouseDeltaY;
         std::array<bool, 5> mouseButtons;
       } input = {};
   
       std::vector<std::shared_ptr<IEntity>> entityPool;
       std::vector<std::shared_ptr<Texture>> texturePool;
       std::unordered_map<std::string, size_t> textureMap;
       std::vector<std::shared_ptr<Object3D>> objectPool;
       std::unordered_map<std::string, size_t> objectMap;
       std::unique_ptr<ShaderProgram> shader = std::make_unique<ShaderProgram>();
       bool isRunning;
       bool glDebug;
       bool isImGUIWindowCreated;
   
       static void DebugCallback(
         GLenum source,
         GLenum type,
         GLuint id,
         GLenum severity,
         GLsizei length,
         const GLchar *message,
         const void *userParam);
   
       void Update();
   
       void Draw();
   
       void HandleEvent();
   
     public:
       Camera camera;  // NOLINT
   
       Demeter() = default;
       ~Demeter() = default;
   
       [[nodiscard]] bool
       Init(std::unique_ptr<SDL2> renderer, bool activateDebug = false);
   
       [[nodiscard]] const InputState &GetInput() const
       {
         return input;
       }
   
       [[nodiscard]] const Time &GetTime() const
       {
         return time;
       }
   
       [[nodiscard]] const std::unique_ptr<ShaderProgram> &GetShader() const
       {
         return shader;
       }
   
       std::shared_ptr<IEntity> AddEntity(std::shared_ptr<IEntity> entity)
       {
         entityPool.push_back(std::move(entity));
         return entityPool.back();
       }
   
       std::shared_ptr<IEntity> GetEntity(size_t index) const
       {
         return entityPool.at(index);
       }
   
       void DeleteEntity(const std::shared_ptr<IEntity> &entity)
       {
         std::ranges::remove(entityPool, entity);
       }
   
       [[nodiscard]] std::shared_ptr<Texture> AddTexture(const std::string &path);
   
       void DeleteTexture(const std::string &path)
       {
         size_t index = textureMap[path];
         textureMap.erase(path);
         texturePool.erase(texturePool.begin() + index);
       }
   
       [[nodiscard]] std::optional<std::shared_ptr<Object3D>>
       AddObject3D(const std::string &path);
   
       void DeleteObject3D(const std::string &path)
       {
         size_t index = objectMap[path];
         objectMap.erase(path);
         objectPool.erase(objectPool.begin() + index);
       }
   
       void SetIsImGuiWindowCreated(bool isCreated)
       {
         isImGUIWindowCreated = isCreated;
       }
   
       void Run();
     };
   
   }  // namespace Dem