scene.h

Go to the documentation of this file.

 
 
#ifndef ASW_SCENE_H
#define ASW_SCENE_H
 
#include <algorithm>
#include <chrono>
#include <iostream>
#include <memory>
#include <ranges>
#include <unordered_map>
#include <vector>
 
#include "./core.h"
#include "./display.h"
#include "./game.h"
 
#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#endif
 
namespace asw::scene {
 
constexpr auto DEFAULT_TIMESTEP = std::chrono::milliseconds(8);
 
template <typename T> class SceneManager;
 
template <typename T> class Scene {
public:
    explicit Scene(SceneManager<T>& manager)
        : manager(manager)
    {
    }
 
    virtual ~Scene() = default;
 
    virtual void init() {
        // Default implementation does nothing
    };
 
    virtual void update(float dt)
    {
        // Erase inactive objects
        std::erase_if(objects_, [](const auto& obj) { return !obj->alive; });
 
        // Update all objects in the scene
        for (auto const& obj : objects_) {
            if (obj->active && obj->alive) {
                obj->update(dt);
            }
        }
 
        // Create new objects
        for (auto const& obj : obj_to_create_) {
            objects_.push_back(obj);
        }
 
        // Clear the objects to create
        obj_to_create_.clear();
    };
 
    virtual void draw()
    {
        // Sort objects by z-index
        std::ranges::sort(objects_, std::less {}, &game::GameObject::z_index);
 
        for (auto const& obj : objects_) {
            if (obj->active) {
                obj->draw();
            }
        }
    };
 
    virtual void cleanup()
    {
        objects_.clear();
    };
 
    void register_object(const std::shared_ptr<game::GameObject>& obj)
    {
        objects_.push_back(obj);
    }
 
    template <typename ObjectType, typename... Args>
    std::shared_ptr<ObjectType> create_object(Args&&... args)
    {
        static_assert(std::is_base_of_v<game::GameObject, ObjectType>,
            "ObjectType must be derived from Scene<T>");
        static_assert(std::is_constructible_v<ObjectType, Args...>,
            "ObjectType must be constructible with the given arguments");
 
        auto obj = std::make_shared<ObjectType>(std::forward<Args>(args)...);
        obj_to_create_.emplace_back(obj);
        return obj;
    }
 
    const std::vector<std::shared_ptr<game::GameObject>>& get_objects() const
    {
        return objects_;
    }
 
    template <typename ObjectType> std::vector<std::shared_ptr<ObjectType>> get_object_view()
    {
        static_assert(std::is_base_of_v<game::GameObject, ObjectType>,
            "ObjectType must be derived from Scene<T>");
 
        std::vector<std::shared_ptr<ObjectType>> result;
        for (const auto& obj : objects_) {
            if (auto casted_obj = std::dynamic_pointer_cast<ObjectType>(obj)) {
                result.push_back(casted_obj);
            }
        }
        return result;
    }
 
protected:
    SceneManager<T>& manager;
 
private:
    std::vector<std::shared_ptr<game::GameObject>> objects_;
 
    std::vector<std::shared_ptr<game::GameObject>> obj_to_create_;
};
 
template <typename T> class SceneManager {
public:
    SceneManager()
    {
#ifdef __EMSCRIPTEN__
        instance_ = this;
        em_time_ = std::chrono::high_resolution_clock::now();
#endif
    }
 
    template <typename SceneType, typename... Args>
    void register_scene(const T scene_id, Args&&... args)
    {
        static_assert(
            std::is_base_of_v<Scene<T>, SceneType>, "SceneType must be derived from Scene<T>");
        static_assert(std::is_constructible_v<SceneType, Args...>,
            "SceneType must be constructible with the given arguments");
 
        auto scene = std::make_shared<SceneType>(std::forward<Args>(args)...);
        scenes_[scene_id] = scene;
    }
 
    void set_next_scene(const T scene_id)
    {
        next_scene_ = scene_id;
        has_next_scene_ = true;
    }
 
    void start()
    {
#ifdef __EMSCRIPTEN__
        emscripten_set_main_loop(SceneManager::loop_emscripten, 0, 1);
#else
 
        using namespace std::chrono_literals;
        std::chrono::nanoseconds lag(0ns);
        auto time_start = std::chrono::high_resolution_clock::now();
        auto last_second = std::chrono::high_resolution_clock::now();
        int frames = 0;
 
        while (!asw::core::exit) {
            auto delta_time = std::chrono::high_resolution_clock::now() - time_start;
            time_start = std::chrono::high_resolution_clock::now();
            lag += std::chrono::duration_cast<std::chrono::nanoseconds>(delta_time);
 
            while (lag >= this->timestep_) {
                update(std::chrono::duration<float>(this->timestep_).count());
                lag -= this->timestep_;
            }
 
            // Draw
            draw();
 
            frames++;
 
            if (std::chrono::high_resolution_clock::now() - last_second >= 1s) {
                fps_ = frames;
                frames = 0;
                last_second = last_second + 1s;
            }
        }
#endif
    }
 
    void update(const float dt)
    {
        asw::core::update();
        change_scene();
 
        if (active_scene_ != nullptr) {
            active_scene_->update(dt);
        }
    }
 
    void draw()
    {
        if (active_scene_ != nullptr) {
            asw::display::clear();
            active_scene_->draw();
            asw::display::present();
        }
    }
 
    void set_timestep(std::chrono::nanoseconds ts)
    {
        timestep_ = ts;
    }
 
    std::chrono::nanoseconds get_timestep() const
    {
        return timestep_;
    }
 
    int get_fps() const
    {
        return fps_;
    }
 
private:
    void change_scene()
    {
        if (!has_next_scene_) {
            return;
        }
 
        if (active_scene_ != nullptr) {
            active_scene_->cleanup();
        }
 
        if (auto it = scenes_.find(next_scene_); it != scenes_.end()) {
            active_scene_ = it->second;
            active_scene_->init();
        }
 
        has_next_scene_ = false;
    }
 
    std::shared_ptr<Scene<T>> active_scene_ { nullptr };
 
    T next_scene_;
 
    bool has_next_scene_ { false };
 
    std::unordered_map<T, std::shared_ptr<Scene<T>>> scenes_;
 
    std::chrono::nanoseconds timestep_ { DEFAULT_TIMESTEP };
 
    int fps_ { 0 };
 
#ifdef __EMSCRIPTEN__
    static SceneManager<T>* instance_;
 
    static std::chrono::high_resolution_clock::time_point em_time_;
 
    static void loop_emscripten()
    {
        if (instance_ != nullptr) {
            auto delta_time = std::chrono::high_resolution_clock::now() - SceneManager::em_time_;
            SceneManager::em_time_ = std::chrono::high_resolution_clock::now();
 
            instance_->update(std::chrono::duration<float>(delta_time).count());
            instance_->draw();
        }
    }
#endif
};
 
#ifdef __EMSCRIPTEN__
template <typename T> SceneManager<T>* SceneManager<T>::instance_ = nullptr;
 
// Start time
template <typename T> auto SceneManager<T>::em_time_ = std::chrono::high_resolution_clock::now();
 
#endif
 
} // namespace asw::scene
 
#endif // ASW_SCENE_H