Univerxel/src/world/Chunk.cpp

#include "Chunk.hpp"

#include <FastNoiseSIMD.h>
#include "materials.hpp"

using namespace world;

#define DENSITY 0.f
#define GRANULARITY 30.f

Chunk::Chunk(const chunk_pos& pos, Generator& rnd) {
    const auto [densitySet, materialSet] = rnd.getChunk(pos, CHUNK_LENGTH);

    for (size_t i = 0; i < CHUNK_SIZE; i++) {
        voxels[i].Density = std::clamp((densitySet[i] + DENSITY) * GRANULARITY, 0.f, 1.f) * UCHAR_MAX;
        voxels[i].Material = voxels[i].Density > 0 ? 1 + std::clamp(static_cast<int>(std::lrint((materialSet[i] + 1) / 2 * (materials::count - 2))),
            0, materials::count - 2) : 0; //NOTE: map (approx -1, 1) to (1, mat_max)
    }
    FastNoiseSIMD::FreeNoiseSet(densitySet);
    FastNoiseSIMD::FreeNoiseSet(materialSet);
}
Chunk::~Chunk() { }

std::optional<Faces> Chunk::update() {
    if(upToDate) {
        return {};
    } else {
        upToDate = true;
        return {toUpdate};
    }
}

void Chunk::set(ushort idx, const Voxel& val) {
    voxels[idx] = val;
    invalidate(
        ((!getNeighborIdx(idx, Face::Up).has_value()) & Faces::Up) |
        ((!getNeighborIdx(idx, Face::Down).has_value()) & Faces::Down) |
        ((!getNeighborIdx(idx, Face::Left).has_value()) & Faces::Left) |
        ((!getNeighborIdx(idx, Face::Right).has_value()) & Faces::Right) |
        ((!getNeighborIdx(idx, Face::Forward).has_value()) & Faces::Forward) |
        ((!getNeighborIdx(idx, Face::Backward).has_value()) & Faces::Backward));
}

std::optional<ushort> Chunk::getNeighborIdx(ushort idx, Face face) {
    switch (face) {
    case Face::Forward:
        if (idx % CHUNK_LENGTH >= CHUNK_LENGTH - 1)
            return {};
        return idx + 1;

    case Face::Backward:
        if (idx % CHUNK_LENGTH <= 0)
            return {};
        return idx - 1;

    case Face::Up:
        if ((idx / CHUNK_LENGTH) % CHUNK_LENGTH >= CHUNK_LENGTH - 1)
            return {};
        return idx + CHUNK_LENGTH;

    case Face::Down:
        if ((idx / CHUNK_LENGTH) % CHUNK_LENGTH <= 0)
            return {};
        return idx - CHUNK_LENGTH;

    case Face::Right:
        if (idx / CHUNK_LENGTH2 >= CHUNK_LENGTH - 1)
            return {};
        return idx + CHUNK_LENGTH2;

    case Face::Left:
        if (idx / CHUNK_LENGTH2 <= 0)
            return {};
        return idx - CHUNK_LENGTH2;

    default:
        return {};
    }
}