Chunk.h

#pragma once
 
#include <glm/glm.hpp>
#include <iostream>
 
#include "../hash.h"
#include "ChunkID.h"
 
#include "LayerBuffer.h"
#include "block/Block.h"
#include "block/BlockState.h"
#include "block/VariantBlock.h"
#include "block/Vertex.h"
#include "data/IChunkData.h"
#include "render/Renderable.h"
 
 
#include <LWGL/buffer/Attributes.h>
 
 
namespace gl {
    class ShaderPipeline;
}
 
namespace engine {
 
    class Block;
    class VariantBlock;
    class MultiBlock;
 
    class World;
    class Engine;
    struct RenderContext;
 
 
    class Chunk : public Renderable,
                  public ISerializable {
      public:
        static inline glm::ivec3 Dims{16, 16, 16};
 
        Chunk(World* world, ChunkID coords, std::unique_ptr<IChunkData> data);
        Chunk(Chunk&) = delete;
        Chunk(Chunk&&) = delete;
        ~Chunk();
 
        const ChunkID& id() const { return m_coords; }
        glm::ivec3 position() const { return m_coords * m_data->dims; }
 
        virtual glm::ivec3 dims() const { return m_data->dims; }
 
        World* world() const { return m_world; }
 
        template <typename T>
        T* worldAs() const {  // The user knows what world the chunk belongs to, thus static_cast
            return static_cast<T*>(m_world);
        }
 
        void populateTerrainData();
        bool generated() const { return m_generated; }
 
        bool generateMesh();
 
 
        const Block* getBlock(glm::ivec3 pos, BlockState** state = nullptr);
        void setBlock(const glm::ivec3& pos, BlockID block);
        void setBlock(const glm::ivec3& pos, BlockID block, BlockState state);
        void setBlock(const glm::ivec3& pos, MultiBlock&& multiBlock);
 
 
        IChunkData* data() { return m_data.get(); }
        const IChunkData* data() const { return m_data.get(); }
 
 
        void render(Engine& engine, const Camera* camera, int pass) override;
 
        VariantBlock::Neighbours getNeighbouringBlocks(glm::ivec3 pos) const;
 
        // TODO probably remove this
        virtual void afterGenerated() {}
 
 
        void serialize(std::ostream& out) const override;
        void deserialize(std::istream& in) override;
 
 
      protected:
        World* m_world;
        ChunkID m_coords;
        std::unique_ptr<IChunkData> m_data;
        bool m_dirty = false;
 
        struct GeometryState {
            glm::vec3 axis;
            float angle;
        };
 
        struct MeshGenContext {
            const Block* block;
            const Geometry* geometry;
            GeometryState geometryState;
            gl::Attributes<Vertex>& storage;
            glm::ivec3 posInChunk;
            glm::ivec3 worldPos;
        };
 
        GeometryState calculateGeometryState(const Block* block, const BlockState* state) const;
        void generateMeshForGeometry(const MeshGenContext& ctx);
 
        void generateMeshForBlock(
            const Block* block,
            glm::ivec3 pos,
            const BlockState* state,
            const glm::ivec3& chunkBlockCoords
        );
        void generateMeshForBlock(
            const VariantBlock* block,
            glm::ivec3 pos,
            const BlockState* state,
            const glm::ivec3& chunkBlockCoords
        );
        void generateMeshForBlock(
            const MultiBlock* block,
            glm::ivec3 pos,
            const BlockState* state,
            const glm::ivec3& chunkBlockCoords
        );
 
      private:
        std::array<LayerBuffer, 3> m_renderLayers;
 
        bool m_generated = false;
        std::atomic_bool m_generatingMesh = false;
 
        friend class World;
    };
 
 
}  // namespace engine