Chunk.h

Go to the documentation of this file.

 
#pragma once
 
#include <FastNoiseLite.h>
#include <immintrin.h>
#include <cstdint>
#include <cstring>
#include <memory>
#include <vector>
 
#include "../core/MathUtils.h"
#include "../physics/AABB.h"
#include "../renderer/Buffer.h"
#include "../renderer/IndexBuffer.h"
#include "../renderer/ThermalVolume.h"
#include "../renderer/VertexArray.h"
 
constexpr int CHUNK_SIZE = 16;
constexpr int CHUNK_HEIGHT = 16;
constexpr int CHUNK_VOL = CHUNK_SIZE * CHUNK_HEIGHT * CHUNK_SIZE;
 
constexpr int PADDED_CHUNK_SIZE = CHUNK_SIZE + 2;
constexpr int PADDED_CHUNK_HEIGHT = CHUNK_HEIGHT + 2;
constexpr int PADDED_CHUNK_VOL = PADDED_CHUNK_SIZE * PADDED_CHUNK_HEIGHT * PADDED_CHUNK_SIZE;
 
enum FaceDirection { FRONT, BACK, LEFT, RIGHT, UP, DOWN };
enum Direction { NORTH = 0, SOUTH, EAST, WEST, ABOVE, BELOW };  // Z+, Z-, X+, X-, Y+, Y-
enum BlockType { AIR = 0, GRASS = 1, DIRT = 2, STONE = 3 };
 
class Chunk {
public:
    Chunk() = delete;
    Chunk(int iX, int iZ);
    ~Chunk();
 
    Chunk(const Chunk&) = delete;
    Chunk& operator=(const Chunk&) = delete;
 
    Chunk(Chunk&& other) noexcept;
    Chunk& operator=(Chunk&& other) noexcept;
 
    [[nodiscard]] int GetChunkX() const { return m_iChunkX; }
    [[nodiscard]] int GetChunkZ() const { return m_iChunkZ; }
 
    [[nodiscard]] bool IsValid() const { return m_pVAO != nullptr; }
    const uint8_t* GetBlockData() const { return m_iBlocks; }
 
    // --- Core Logic ---
 
    AABB GetAABB() const;
 
    void Render() const;
 
    void SetNeighbours(Direction iDir, Chunk* pChunk) { m_pNeighbours[iDir] = pChunk; }
 
    // --- Block Manipulation ---
 
    [[nodiscard]] inline int GetFlatIndexOf3DLayer(int iX, int iY, int iZ) const {
        if (iX < 0 || iX >= CHUNK_SIZE || iY < 0 || iY >= CHUNK_HEIGHT || iZ < 0 ||
            iZ >= CHUNK_SIZE) {
            return -1;
        }
 
        return iX + (iY * CHUNK_SIZE) + (iZ * CHUNK_SIZE * CHUNK_HEIGHT);
    }
 
    [[nodiscard]] inline int GetPaddedIndexOf3DLayer(int iX, int iY, int iZ) const {
        if (iX < -1 || iX >= CHUNK_SIZE + 1 || iY < -1 || iY >= CHUNK_HEIGHT + 1 || iZ < -1 ||
            iZ >= CHUNK_SIZE + 1) {
            return -1;
        }
        // +1 for padding buffer of neighbour data
        return (iX + 1) + ((iY + 1) * PADDED_CHUNK_SIZE) +
               ((iZ + 1) * PADDED_CHUNK_SIZE * PADDED_CHUNK_HEIGHT);
    }
 
    // --- Block Manipulation for SIMD ---
 
    [[nodiscard]] inline __m256i GetFlatIndexOf3DLayer_AVX2(__m256i vecX,
                                                            __m256i vecY,
                                                            __m256i vecZ) const {
        __m256i vecChunkSize = _mm256_set1_epi32(CHUNK_SIZE);
        __m256i vecChunkSizeHeight = _mm256_set1_epi32(CHUNK_SIZE * CHUNK_HEIGHT);
 
        __m256i vecIndex =
            _mm256_add_epi32(_mm256_add_epi32(vecX, _mm256_mullo_epi32(vecY, vecChunkSize)),
                             _mm256_mullo_epi32(vecZ, vecChunkSizeHeight));
 
        return vecIndex;
    }
 
    uint8_t GetBlockAt(int iX, int iY, int iZ) const {
        // Quick check for internal blocks
        if (iX >= 0 && iX < CHUNK_SIZE && iY >= 0 && iY < CHUNK_HEIGHT && iZ >= 0 &&
            iZ < CHUNK_SIZE) {
            return m_iBlocks[iX + (iY * CHUNK_SIZE) + (iZ * CHUNK_SIZE * CHUNK_HEIGHT)];
        }
 
        // Boundary checks (Neighbor querying)
        if (iX < 0)
            return m_pNeighbours[Direction::WEST]
                       ? m_pNeighbours[Direction::WEST]->GetBlockAt(CHUNK_SIZE - 1, iY, iZ)
                       : 0;
        if (iX >= CHUNK_SIZE)
            return m_pNeighbours[Direction::EAST]
                       ? m_pNeighbours[Direction::EAST]->GetBlockAt(0, iY, iZ)
                       : 0;
 
        if (iY < 0)
            return m_pNeighbours[Direction::BELOW]
                       ? m_pNeighbours[Direction::BELOW]->GetBlockAt(iX, CHUNK_SIZE - 1, iZ)
                       : 0;
        if (iY >= CHUNK_HEIGHT)
            return m_pNeighbours[Direction::ABOVE]
                       ? m_pNeighbours[Direction::ABOVE]->GetBlockAt(iX, 0, iZ)
                       : 0;
 
        if (iZ < 0)
            return m_pNeighbours[Direction::SOUTH]
                       ? m_pNeighbours[Direction::SOUTH]->GetBlockAt(iX, iY, CHUNK_SIZE - 1)
                       : 0;
        if (iZ >= CHUNK_SIZE)
            return m_pNeighbours[Direction::NORTH]
                       ? m_pNeighbours[Direction::NORTH]->GetBlockAt(iX, iY, 0)
                       : 0;
 
        return 0;  // Default to Air
    }
 
    void SetBlockAt(int iX, int iY, int iZ, uint8_t uiBlockType);
 
    void SetBlockData(const uint8_t* iBlocks) {
        if (iBlocks)
            std::memcpy(m_iBlocks, iBlocks, CHUNK_VOL * sizeof(uint8_t));
    }
 
    float GetTemperatureAt(int iX, int iY, int iZ) const;
 
    void ReconstructMesh(bool bEnableNeighborCulling = false);
    void UploadMesh();
    void SwapBuffers() { std::swap(m_pfCurrFrameData, m_pfNextFrameData); }
    void InjectHeat(int iX, int iY, int iZ, float fTemp) {
        int iIndex = GetPaddedIndexOf3DLayer(iX, iY, iZ);
        if (iIndex != -1) {
            m_pfCurrFrameData[iIndex] = fTemp;
        }
    }
    void ThermalStep(float fThermalDiffusivity, float fDeltaTime);
    void ThermalStep_AVX2(float fThermalDiffusivity, float fDeltaTime);
 
    float* GetCurrData() const { return m_pfCurrFrameData; }
    void UpdateThermalTexture();
    void Bind(int iVal) {
        if (m_pThermalTex)
            m_pThermalTex->Bind(iVal);
    }
 
    void GetMeshStats(size_t& uiOutVertCount, size_t& uiOutTriCount) const {
        uiOutVertCount = m_uiVertexCount;
        uiOutTriCount = m_uiTriangleCount;
    }
 
private:
    std::vector<float> m_vec_fVertices;
    std::vector<unsigned int> m_vec_uiIndices;
    size_t m_uiVertexCount = 0;
    size_t m_uiTriangleCount = 0;
    Renderer::VertexArray* m_pVAO = nullptr;
    Renderer::VertexBuffer* m_pVBO = nullptr;
    Renderer::IndexBuffer* m_pIBO = nullptr;
 
    Chunk* m_pNeighbours[6] = {nullptr};
 
    float* m_pfCurrFrameData = nullptr;
    float* m_pfNextFrameData = nullptr;
    std::unique_ptr<Renderer::ThermalVolume> m_pThermalTex;
 
    // Per-chunk noise instance (Consider moving to a global generator for efficiency)
    FastNoiseLite noise{};
    int m_iHeightData[CHUNK_SIZE][CHUNK_SIZE];
    int m_iChunkX = 0, m_iChunkZ = 0;
    uint8_t m_iBlocks[CHUNK_VOL]{0};
    bool m_bVonNeumannBC = true;
 
    void updateHeightData();
    void updateBuffers();
    void addBlockFace(int iX, int iY, int iZ, FaceDirection iDir, int iBlockType);
};