rabbithole - a first attempt at a language.

Age	Commit message (Expand)	Author
2021-10-18	Basic expression parsing	Mel
2021-10-17	Lexing	Mel
#include "Chunk.hpp"
#include "BlockSide.hpp"

namespace MC::World {

void Chunk::set(uint32_t x, uint32_t y, uint32_t z, BlockType type) {
    m_blocks[x][y][z].type = type;
}

GFX::Mesh Chunk::mesh() {
    std::vector<Vector<3>> positions{};
    std::vector<Vector<3>> normals{};
    std::vector<Vector<2>> tex_coords{};
    std::vector<uint32_t> indices{};

    for (int x = 0; x < CHUNK_WIDTH; x++) {
        for (int y = 0; y < CHUNK_HEIGHT; y++) {
            for (int z = 0; z < CHUNK_WIDTH; z++) {
                auto type = m_blocks[x][y][z].type;
                if (type == BlockType::Air) {
                    continue;
                }

                for (auto side: BlockSide::all()) {
                    if (!is_face_visible(x, y, z, side)) {
                        continue;
                    }

                    auto side_positions = side.face();
                    auto side_normals = Chunk::face_normals(side);
                    auto side_tex_coords = Chunk::face_tex_coords(type, side);

                    for (auto& position : side_positions) {
                        position = position + Vector<3>{static_cast<float>(x), static_cast<float>(y), static_cast<float>(z)};
                    }

                    uint32_t s = positions.size();

                    positions.insert(positions.end(), side_positions.begin(), side_positions.end());
                    normals.insert(normals.end(), side_normals.begin(), side_normals.end());
                    tex_coords.insert(tex_coords.end(), side_tex_coords.begin(), side_tex_coords.end());
                    indices.insert(indices.end(), {s, s + 1, s + 3, s + 1, s + 2, s + 3});
                }
            }
        }
    }

    return {
        {positions, normals, tex_coords},
        indices,
    };
}

Vector<3> Chunk::position() {
    return m_position;
}

bool Chunk::is_face_visible(uint32_t x, uint32_t y, uint32_t z, BlockSide side) {
    Vector<3, int32_t> offset{};
    switch (side) {
        case BlockSide::Front:
            offset[2] = 1;
            break;
        case BlockSide::Back:
            offset[2] = -1;
            break;
        case BlockSide::Top:
            offset[1] = 1;
            break;
        case BlockSide::Bottom:
            offset[1] = -1;
            break;
        case BlockSide::Left:
            offset[0] = -1;
            break;
        case BlockSide::Right:
            offset[0] = 1;
            break;
    }

    Vector<3, uint32_t> neighbor_pos{
        x + offset.x(), y + offset.y(), z + offset.z(),
    };

    if (
        neighbor_pos.x() >= CHUNK_WIDTH || neighbor_pos.x() < 0 ||
        neighbor_pos.y() >= CHUNK_HEIGHT || neighbor_pos.y() < 0 ||
        neighbor_pos.z() >= CHUNK_WIDTH || neighbor_pos.z() < 0
    ) {
        return true;
    }

    auto neighbor = m_blocks[neighbor_pos.x()][neighbor_pos.y()][neighbor_pos.z()];
    if (neighbor.type == BlockType::Air) {
        return true;
    }

    return false;
}

std::array<Vector<2>, 4> Chunk::face_tex_coords(BlockType type, BlockSide side) {
    switch (type) {
        case BlockType::Dirt:
            return {{
                {0.5f, 0.0f}, {1.0f, 0.0f}, {1.0f, 0.5f}, {0.5f, 0.5f},
            }};
        case BlockType::Grass:
            switch (side) {
                case BlockSide::Front:
                case BlockSide::Back:
                case BlockSide::Left:
                case BlockSide::Right:
                    return {{
                        {0.5f, 1.0f}, {0.0f, 1.0f},  {0.0f, 0.5f}, {0.5f, 0.5f},
                    }};
                case BlockSide::Top:
                    return {{
                        {0.0f, 0.0f}, {0.5f, 0.0f}, {0.5f, 0.5f}, {0.0f, 0.5f},
                    }};
                case BlockSide::Bottom:
                    return {{
                        {0.5f, 0.0f}, {1.0f, 0.0f}, {1.0f, 0.5f}, {0.5f, 0.5f},
                    }};
            }
        default:
            return {};
    }
}

std::array<Vector<3>, 4> Chunk::face_normals(BlockSide side) {
    auto is_side = [=](BlockSide s) -> float { return s == side; };

    Vector<3> normal = {
            is_side(BlockSide::Right) - is_side(BlockSide::Left),
            is_side(BlockSide::Top) - is_side(BlockSide::Bottom),
            is_side(BlockSide::Front) - is_side(BlockSide::Back),
    };

    return {normal, normal, normal, normal};
}

}