World.h

#pragma once
 
#include <future>
#include <glm/glm.hpp>
#include <memory>
#include <mutex>
#include <optional>
#include <unordered_map>
#include <unordered_set>
 
#include "events/LevelEventSource.h"
 
#include "Chunk.h"
#include "ITerrainGenerator.h"
#include "render/Material.h"
#include "render/Renderable.h"
#include "scene/Skybox.h"
#include "scene/Updateable.h"
#include "utility/ThreadPool.h"
 
 
namespace gl {
    class ShaderPipeline;
}
 
namespace engine {
    class Chunk;
    class Engine;
    struct ChunkID;
    struct RenderContext;
 
    class World : public Renderable,
                  public Updateable,
                  public LevelEventSource {
      public:
        World(std::unique_ptr<ITerrainGenerator> gen, uint32_t genThreads = 8);
        World(std::unique_ptr<ITerrainGenerator> gen, glm::ivec3 chunkDims, uint32_t genThreads = 8);
        ~World();
 
        glm::ivec3 chunkDims() const { return m_chunkDims; }
 
 
        virtual std::future<void> loadChunks(
            const glm::ivec3& from, const glm::ivec3& to, bool unloadRest = false
        );
 
        virtual void unloadChunks(const glm::ivec3& from, const glm::ivec3& to);
 
        void unloadAllChunks(const std::vector<ChunkID>& except = {});
 
        void unloadChunksFromMemory(const std::vector<ChunkID>& ids);
 
        std::shared_ptr<Chunk> getChunk(const ChunkID& id);
        std::shared_ptr<const Chunk> getChunk(const ChunkID& id) const;
 
        template <typename T>
        std::shared_ptr<T> getChunkAs(const ChunkID& id);
 
        template <typename T>
        std::shared_ptr<const T> getChunkAs(const ChunkID& id) const;
 
        const std::unordered_set<ChunkID>& loadedChunks() const { return m_loadedChunks; }
 
        void checkAndUpdateSurroundingChunks(const ChunkID& chID, const glm::ivec3& pos);
 
 
        BlockID getBlockID(
            const ChunkID& chID,
            const glm::ivec3& pos,
            bool fallbackToGenerator,
            BlockState** state = nullptr
        );
 
        void setBlock(
            const ChunkID& chID,
            const glm::ivec3& pos,
            BlockID blockID,
            std::optional<BlockState> state = std::nullopt
        );
        void setBlock(const ChunkID& chID, const glm::ivec3& pos, MultiBlock&& multiBlock);
        MultiBlock* getMultiBlock(const ChunkID& chID, const glm::ivec3& pos);
 
 
        void setBlock(
            glm::ivec3 pos, BlockID blockID, std::optional<BlockState> state = std::nullopt
        );
        void setBlock(glm::ivec3 pos, MultiBlock&& multiBlock);
        MultiBlock* getMultiBlock(glm::ivec3 pos);
 
        BlockID getBlockID(glm::vec3 pos, bool fallbackToGenerator, BlockState** state = nullptr);
 
        const ITerrainGenerator* getGenerator() const { return m_generator.get(); }
        const Material& getMaterial() const { return m_material; }
        Skybox& getSkybox() { return m_skybox; }
 
        virtual void render(Engine& engine, const Camera* camera, int pass = 0) override;
        virtual void update(float dt) override;
 
 
 
 
        virtual void afterBlockSet(
            const glm::ivec3& pos, BlockID blockID, BlockState* state = nullptr
        ) {}
        // virtual void multiBlockUpdated(const glm::ivec3& pos, MultiBlock* block) {};
 
      protected:
        std::unordered_map<ChunkID, std::shared_ptr<Chunk>> m_chunks;
        std::unordered_set<ChunkID> m_loadedChunks;
        std::unique_ptr<ITerrainGenerator> m_generator = nullptr;
        glm::ivec3 m_chunkDims;
 
        Material m_material;
        Skybox m_skybox;
 
        ThreadPool m_genPool;
 
        virtual std::shared_ptr<Chunk> createChunk(const ChunkID& id);
 
        bool canSeeFace(const Block& curBlock, glm::vec3 pos, glm::ivec3 dir) const;
 
 
        friend class Chunk;
 
      private:
        void updateChunk(ChunkID id);
        mutable std::mutex m_mutex;
    };
 
    template <typename T>
    std::shared_ptr<T> World::getChunkAs(const ChunkID& id) {
        static_assert(std::is_base_of<Chunk, T>::value, "T must inherit from Chunk");
        auto chunk = getChunk(id);
        return std::static_pointer_cast<T>(chunk);
    }
 
    template <typename T>
    std::shared_ptr<const T> World::getChunkAs(const ChunkID& id) const {
        static_assert(std::is_base_of<Chunk, T>::value, "T must inherit from Chunk");
        auto chunk = getChunk(id);
        return std::static_pointer_cast<const T>(chunk);
    }
 
}  // namespace engine