scene.h

Go to the documentation of this file.

 
 
#ifndef ASW_SCENE_H
#define ASW_SCENE_H
 
#include <chrono>
#include <iostream>
#include <memory>
#include <unordered_map>
#include <vector>
 
#include "./core.h"
#include "./display.h"
#include "./game.h"
 
#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#endif
 
namespace asw::scene {
  using namespace std::chrono_literals;
 
  constexpr auto DEFAULT_TIMESTEP = 8ms;
 
  template <typename T>
  class SceneManager;
 
  template <typename T>
  class Scene {
   public:
    explicit Scene(SceneManager<T>& sceneManager)
        : sceneManager(sceneManager) {}
 
    virtual ~Scene() = default;
 
    virtual void init() {};
 
    virtual void update(float deltaTime) {
      // Erase inactive objects
      objects.erase(
          std::remove_if(objects.begin(), objects.end(),
                         [](const std::shared_ptr<game::GameObject>& obj) {
                           return !obj->alive;
                         }),
          objects.end());
 
      // Update all objects in the scene
      for (auto& obj : objects) {
        if (obj->active && obj->alive) {
          obj->update(deltaTime);
        }
      }
 
      // Create new objects
      for (auto& obj : objectsToCreate) {
        objects.push_back(obj);
      }
 
      // Clear the objects to create
      objectsToCreate.clear();
    };
 
    virtual void draw() {
      // Sort objects by z-index
      std::sort(objects.begin(), objects.end(),
                [](const std::shared_ptr<game::GameObject>& a,
                   const std::shared_ptr<game::GameObject>& b) {
                  return a->zIndex < b->zIndex;
                });
 
      for (auto& obj : objects) {
        if (obj->active) {
          obj->draw();
        }
      }
    };
 
    virtual void cleanup() { objects.clear(); };
 
    void registerObject(const std::shared_ptr<game::GameObject> obj) {
      objects.push_back(obj);
    }
 
    template <typename ObjectType, typename... Args>
    std::shared_ptr<ObjectType> createObject(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)...);
      objectsToCreate.emplace_back(obj);
      return obj;
    }
 
    std::vector<std::shared_ptr<game::GameObject>> getObjects() {
      return objects;
    }
 
    template <typename ObjectType>
    std::vector<std::shared_ptr<ObjectType>> getObjectView() {
      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 castedObj = std::dynamic_pointer_cast<ObjectType>(obj)) {
          result.push_back(castedObj);
        }
      }
      return result;
    }
 
   protected:
    SceneManager<T>& sceneManager;
 
   private:
    std::vector<std::shared_ptr<game::GameObject>> objects;
 
    std::vector<std::shared_ptr<game::GameObject>> objectsToCreate;
  };
 
  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 registerScene(const T sceneId, 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[sceneId] = scene;
    }
 
    void setNextScene(const T sceneId) {
      nextScene = sceneId;
      hasNextScene = true;
    }
 
    void start() {
#ifdef __EMSCRIPTEN__
      emscripten_set_main_loop(SceneManager::loopEmscripten, 0, 1);
#else
 
      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 deltaTime) {
      asw::core::update();
      changeScene();
 
      if (activeScene != nullptr) {
        activeScene->update(deltaTime);
      }
    }
 
    void draw() {
      if (activeScene != nullptr) {
        asw::display::clear();
        activeScene->draw();
        asw::display::present();
      }
    }
 
    void setTimestep(std::chrono::nanoseconds ts) { timestep = ts; }
 
    std::chrono::nanoseconds getTimestep() const { return timestep; }
 
    int getFPS() const { return fps; }
 
   private:
    void changeScene() {
      if (!hasNextScene) {
        return;
      }
 
      if (activeScene != nullptr) {
        activeScene->cleanup();
      }
 
      if (auto it = scenes.find(nextScene); it != scenes.end()) {
        activeScene = it->second;
        activeScene->init();
      }
 
      hasNextScene = false;
    }
 
    std::shared_ptr<Scene<T>> activeScene;
 
    T nextScene;
 
    bool hasNextScene{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 loopEmscripten() {
      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