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. Scanning first keeps the compaction pass off
        // frames where nothing actually died.
        if (std::ranges::any_of(_objects, [](const auto& obj) { return !obj->alive; })) {
            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
        if (!_obj_to_create.empty()) {
            _objects.reserve(_objects.size() + _obj_to_create.size());
            _objects.insert(_objects.end(), _obj_to_create.begin(), _obj_to_create.end());
        }
 
        // Clear the objects to create
        _obj_to_create.clear();
    };
 
    virtual void draw()
    {
        // Sort objects by z-index. The check is a linear read, so already
        // ordered scenes skip the sort entirely.
        if (!std::ranges::is_sorted(_objects, std::less {}, &game::GameObject::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::is_exiting()) {
            const auto now = std::chrono::high_resolution_clock::now();
            auto delta_time = now - time_start;
            time_start = 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 (now - last_second >= 1s) {
                _fps = frames;
                frames = 0;
                last_second = last_second + 1s;
            }
        }
 
        // Cleanup
        cleanup();
#endif
    }
 
    void cleanup()
    {
        if (_active_scene != nullptr) {
            _active_scene->cleanup();
        }
 
        _scenes.clear();
    }
 
    void update(const float dt)
    {
        if (asw::core::is_exiting()) {
            return;
        }
 
        asw::core::update();
        change_scene();
 
        if (_active_scene != nullptr) {
            _active_scene->update(dt);
        }
    }
 
    void draw()
    {
        if (asw::core::is_exiting()) {
            return;
        }
 
        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) {
            const auto now = std::chrono::high_resolution_clock::now();
            auto delta_time = now - SceneManager::em_time_;
            SceneManager::em_time_ = 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