Engine.hpp

/*
** ETIB PROJECT, 2026
** evan
** File description:
** Engine
*/
 
#pragma once
 
#include <chrono>
#include <limits>
#include <utility/graphic/material.hpp>
 
#include "evan/Version.hpp"
 
#include "evan/DeviceContext.hpp"
#include "evan/RenderSettings.hpp"
#include "evan/Renderer.hpp"
#include "evan/ASwapchainContext.hpp"
#include "evan/IPlatform.hpp"
 
#include <glm/glm.hpp>
 
#include <utility/graphic/model.hpp>
#include <utility/graphic/primitive.hpp>
#include <utility/graphic/view.hpp>
#include <utility/graphic/text/text.hpp>
 
#include <utility/ressource_provider.hpp>
 
#include <utility/event/event.hpp>
#include <utility/event/keyboard_event.hpp>
#include <utility/event/mouse_motion_event.hpp>
#include <utility/event/mouse_button_event.hpp>
#include <utility/event/hand_motion_event.hpp>
#include <utility/event/hand_thumb_stick_event.hpp>
 
#include <utility/logging/loggable.hpp>
#include <utility/logging/default_logger.hpp>
 
#include <utility/engine.hpp>
 
#include "RenderObject.hpp"
#include "RessourceManager.hpp"
 
#include <string>
#include <memory>
 
namespace evan
{
    class Engine: public utility::Engine
    {
        public:
        Engine(std::shared_ptr<utility::RessourceProvider> ressourceProvider,
               std::shared_ptr<IPlatform> platform,
               RenderSettings settings = {});
 
        ~Engine();
 
        bool setObjectTransform(size_t objectID, const glm::mat4 &transform);
 
        void setInstancingEnabled(bool enabled);
 
        [[nodiscard]] bool isInstancingEnabled() const;
 
        void setIndirectDrawingEnabled(bool enabled);
 
        [[nodiscard]] bool isIndirectDrawingEnabled() const;
 
        utility::graphic::ViewF getView(void) const override;
 
        utility::graphic::SizeF
            measureText(const utility::graphic::Text &text) const override;
 
        size_t addMesh(const utility::graphic::Mesh &mesh,
                       const std::string &materialName = "default_material",
                       const std::string &shader       = "default");
 
        size_t createObject(
            std::shared_ptr<utility::graphic::Renderable> object) override;
 
        bool updateObject(std::shared_ptr<utility::graphic::Renderable> object,
                          size_t objectID) override;
 
        bool removeObject(std::shared_ptr<utility::graphic::Renderable> object,
                          size_t objectID) override;
 
        void update() override;
 
        void clear(void) override;
 
        void present(void) override;
 
        Error render();    // For rendering the render objects.
 
        float getDeltaTime(void) const override;
 
        [[nodiscard]] const FrameStats &getFrameStats() const;
 
        void setScissor(const utility::graphic::ScissorRect &rect) override;
 
        void clearScissor(void) override;
 
        Error getLastError() const;
 
        void pollEvents() override;
 
        bool shouldCaptureViewportInput(void) const
        {
            return _shouldCaptureViewportInput;
        }
 
        void setShouldCaptureViewportInput(bool shouldCapture)
        {
            _shouldCaptureViewportInput = shouldCapture;
        }
 
        float getTargetFps(void) const
        {
            return _targetFps;
        }
 
        void setTargetFps(float fps)
        {
            _targetFps = fps;
        }
 
        protected:
        const std::string _engineName = "Evan Engine";
 
        const std::string _engineVersion = "0.1.0";
 
        const std::shared_ptr<Version> _version =
            std::make_shared<Version>(0, 1, 0);
 
        std::shared_ptr<DeviceContext> _deviceContext;
 
        std::shared_ptr<Renderer> _renderer;
 
        std::shared_ptr<ASwapchainContext> _swapchainContext;
 
        std::shared_ptr<IPlatform> _platform;
 
        std::shared_ptr<utility::RessourceProvider> _ressourceProvider;
 
        std::shared_ptr<RessourceManager> _ressourceManager;
 
        private:
        bool _shouldCaptureViewportInput = true;
 
        std::vector<std::shared_ptr<utility::event::Event>>
            _capturedViewportEvents;
 
        bool _isRightMouseButtonPressed = false;
 
        utility::math::Vector2F _lastMousePosition { 0.0f, 0.0f };
 
        size_t _debugRayObjectID = std::numeric_limits<size_t>::max();
 
        private:
        void handleViewportInput(
            const std::vector<std::shared_ptr<utility::event::Event>> &events);
 
        void handleKeyboardMovement(
            const std::shared_ptr<utility::event::KeyboardEvent> &keyboardEvent,
            const utility::graphic::OrientationF &orientation,
            utility::graphic::PositionF &position, float movementSpeed,
            float deltaTime);
 
        void handleMouseButtonEvent(
            const std::shared_ptr<utility::event::MouseButtonEvent>
                &mouseButtonEvent,
            bool &isRightMouseButtonPressed,
            utility::math::Vector2F &lastMousePosition);
 
        void handleMouseMotionEvent(
            const std::shared_ptr<utility::event::MouseMotionEvent>
                &mouseMotionEvent,
            bool isRightMouseButtonPressed,
            utility::math::Vector2F &lastMousePosition,
            utility::graphic::OrientationF &orientation, float rotationSpeed,
            float deltaTime);
 
        void handleHandMotionEvent(
            const std::shared_ptr<utility::event::HandMotionEvent>
                &handMotionEvent,
            utility::graphic::PositionF &position,
            utility::graphic::OrientationF &orientation, float movementSpeed,
            float rotationSpeed, float deltaTime);
 
        void handleThumbStickEvent(
            const std::shared_ptr<utility::event::HandThumbStickEvent>
                &thumbStickEvent,
            utility::graphic::PositionF &position,
            utility::graphic::OrientationF &orientation, float movementSpeed,
            float rotationSpeed, float deltaTime);
 
        void updateDebugRay(const utility::graphic::RayF &ray);
 
        std::chrono::steady_clock::time_point _lastFrameTime;
 
        float _deltaTime { 0.0f };
 
        float _targetFps { 0.0f };
 
        void updateDeltaTime(void);
    };
}    // namespace evan