AstralTransRocketries/LucidCube
1
0
Fork 0
Code Issues Pull Requests Packages Projects 1 Releases Wiki Activity

Start merging in elements from server into client

Browse Source 
Did some changes to distinguish our chunks from the cuberite ones, also
changed the ITEM ids to be using cuberite.
Changing some constants to use cChunkDef::

This is only part one of many, its quite difficult to do a quick change
due to the different XYZ referencing system. Currently this is built
with entirely 2d in mind, getting it to play nicely with 3d will be a
bit of a challenge for the while.
This commit is contained in:
Rebekah 2024-02-15 05:53:56 -05:00
parent cc71f0613b
commit 0b817aabb7
Signed by: oneechanhax
GPG Key ID: 183EB7902964DAE5
1 changed files with 292 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

589
src/nyqubel-client/client.cpp
View File

@ -49,6 +49,8 @@
#include "Root.h"
#include "ChatColor.h"
#include "ChunkDef.h"
#include "BlockType.h"
namespace x11 {
@ -211,14 +213,6 @@ public:
namespace qubel {
enum VoxelTypes {
kAir,
kStone,
kDirt,
kSand,
kGrass
};
enum CardinalDirections {
kNorth,
kSouth,
@ -228,274 +222,272 @@ enum CardinalDirections {
kDown*/
};
class Chunk {
class FalseChunk {
public:
// "typedefs" or templates go here lol
static constexpr uint _dim_length = 2; // its in 2d!
static constexpr uint _size_in_power = 16; // 8x8 size
static constexpr std::size_t _chunk_array_size = _size_in_power * _size_in_power;
static constexpr std::size_t _chunk_array_size = cChunkDef::Width * cChunkDef::Width;
using BlockType = uint8_t;
// Using a single digit to locate the exact voxel's byte in the chunk, for very fast use.
using ChunkDataType = std::array<uint8_t, _chunk_array_size>;
using ChunkVecType = geo::internal::BVec2<uint8_t>;
ChunkDataType raw_chunk_data = {
kStone,
kStone,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kStone,
kStone,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kGrass,
kGrass,
kGrass,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kGrass,
kDirt,
kDirt,
kDirt,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kGrass,
kGrass,
kDirt,
kDirt,
kDirt,
kDirt,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kSand,
kSand,
kDirt,
kDirt,
kDirt,
kStone,
kStone,
kStone,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kSand,
kSand,
kDirt,
kDirt,
kStone,
kStone,
kStone,
kStone,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kSand,
kAir,
kSand,
kAir,
kSand,
kAir,
kAir,
kAir,
kSand,
kAir,
kSand,
kAir,
kSand,
kAir,
kAir,
kAir,
kSand,
kAir,
kSand,
kAir,
kSand,
kAir,
kSand,
kAir,
kSand,
kAir,
kSand,
kAir,
kSand,
kAir,
kAir,
kAir,
kSand,
kAir,
kSand,
kAir,
kAir,
kSand,
kAir,
kSand,
kAir,
kAir,
kSand,
kAir,
kSand,
kAir,
kAir,
kAir,
kAir,
kSand,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kSand,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kAir,
kStone,
ENUM_BLOCK_TYPE::E_BLOCK_STONE,
ENUM_BLOCK_TYPE::E_BLOCK_STONE,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_STONE,
ENUM_BLOCK_TYPE::E_BLOCK_STONE,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_GRASS,
ENUM_BLOCK_TYPE::E_BLOCK_GRASS,
ENUM_BLOCK_TYPE::E_BLOCK_GRASS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_GRASS,
ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_GRASS,
ENUM_BLOCK_TYPE::E_BLOCK_GRASS,
ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
ENUM_BLOCK_TYPE::E_BLOCK_STONE,
ENUM_BLOCK_TYPE::E_BLOCK_STONE,
ENUM_BLOCK_TYPE::E_BLOCK_STONE,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
ENUM_BLOCK_TYPE::E_BLOCK_STONE,
ENUM_BLOCK_TYPE::E_BLOCK_STONE,
ENUM_BLOCK_TYPE::E_BLOCK_STONE,
ENUM_BLOCK_TYPE::E_BLOCK_STONE,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_AIR,
ENUM_BLOCK_TYPE::E_BLOCK_STONE,
};
class LocalVoxel {
public:
@ -503,23 +495,23 @@ public:
// LocalVoxel(geo::internal::BVec2<uint8_t> raw_chunk_pos)
//: pos(raw_chunk_pos) { }
static LocalVoxel GetVoxelFromPosInChunk(geo::internal::BVec2<uint8_t> in_pos) { // basicly your 2d/3d position to a index, make sure ur in the chunk! lol
assert(in_pos.x < _size_in_power && in_pos.y < _size_in_power);
assert(in_pos.x < cChunkDef::Width && in_pos.y < cChunkDef::Width);
LocalVoxel index;
index.pos = 0;
return index.AddPos(in_pos);
}
LocalVoxel& AddPos(geo::internal::BVec2<uint8_t> in_pos) {
this->pos += in_pos.x;
this->pos += in_pos.y * _size_in_power;
this->pos += in_pos.y * cChunkDef::Width;
// if constexpr (_dim_length >= 3) // We gotta move these to a seperate class all-together... do this once the templates are split.
// index.pos += in_pos.z * (_size_in_power * _size_in_power);
// index.pos += in_pos.z * (cChunkDef::Width * cChunkDef::Width);
return *this;
}
ChunkVecType ExtractVec() const {
ChunkVecType ret_pos;
ret_pos.x = this->pos % _size_in_power;
ret_pos.y = (this->pos / _size_in_power) % _size_in_power;
// ret_pos.z = ((this->pos / _size_in_power) / _size_in_power) % _size_in_power;
ret_pos.x = this->pos % cChunkDef::Width;
ret_pos.y = (this->pos / cChunkDef::Width) % cChunkDef::Width;
// ret_pos.z = ((this->pos / cChunkDef::Width) / cChunkDef::Width) % cChunkDef::Width;
return ret_pos;
}
// tmp, TODO replace/add with chunk pointer or chunk x and y... both??? oof if so
@ -610,11 +602,14 @@ public:
glez::rgba clr;
};
static constexpr glez::rgba chunk_textures[] = {
glez::rgba(0, 0, 0, 0),
glez::rgba(40, 40, 40),
glez::rgba(120, 40, 40),
glez::color::yellow,
glez::color::green
glez::rgba(0, 0, 0, 0), // air
glez::rgba(40, 45, 45), // stone
glez::color::green, // grass
glez::rgba(22, 17, 17), // dirt
glez::rgba(60, 60, 60), // cobble
glez::rgba(120, 40, 40), // planks
glez::color::green, // sapling
glez::color::black // bedrock
};
std::vector<ChunkMeshedQuad> MeshChunk(MesherComplexity cmplxity) const {
std::vector<ChunkMeshedQuad> finished_quads;
@ -624,11 +619,11 @@ public:
case MesherComplexity::kNieve: // I dont think this is possible in 2d for the time being...
case MesherComplexity::kPlain: {
std::cout << "Plain" << std::endl;
for (uint dim_x = 0; dim_x < _size_in_power; dim_x++) {
for (uint dim_y = 0; dim_y < _size_in_power; dim_y++) {
for (uint dim_x = 0; dim_x < cChunkDef::Width; dim_x++) {
for (uint dim_y = 0; dim_y < cChunkDef::Width; dim_y++) {
const LocalVoxel cube = GetVoxelFromPosInChunk({ dim_x, dim_y });
const auto type = this->GetVoxelType(cube);
if (type == VoxelTypes::kAir)
if (type == ENUM_BLOCK_TYPE::E_BLOCK_AIR)
continue;
ChunkMeshedQuad new_face;
const auto start = geo::Vec2(dim_x * box_size, dim_y * box_size);
@ -651,8 +646,8 @@ public:
std::cout << "Greedy" << std::endl;
std::bitset<_chunk_array_size> chunk_finished_checksum;
const auto FindOpenSpace = [&]() -> std::pair<std::size_t, std::optional<decltype(chunk_finished_checksum)::reference>> {
for (std::size_t x = 0; x < _size_in_power; x++) {
for (std::size_t y = 0; y < _size_in_power; y++) {
for (std::size_t x = 0; x < cChunkDef::Width; x++) {
for (std::size_t y = 0; y < cChunkDef::Width; y++) {
auto vox = this->GetVoxelFromPosInChunk({ x, y });
if (!chunk_finished_checksum[vox.pos])
return { vox.pos, chunk_finished_checksum[vox.pos] };
@ -668,7 +663,7 @@ public:
LocalVoxel cube;
cube.pos = unmeshed_face.first;
const auto type = this->GetVoxelType(cube);
if (type == VoxelTypes::kAir) {
if (type == ENUM_BLOCK_TYPE::E_BLOCK_AIR) {
chunk_finished_checksum[cube.pos] = true;
continue;
}
@ -682,7 +677,7 @@ public:
// Need a better "search line down" func... instead of one block we need to check multiple and return how many are the same.
constexpr auto south_dir_mask = AxisIterator::CreateCardinalMask(CardinalDirections::kSouth);
auto SearchLineSouthForSameTypes = [&](ChunkVecType src_line, std::uint8_t max_size = _size_in_power) -> std::uint8_t {
auto SearchLineSouthForSameTypes = [&](ChunkVecType src_line, std::uint8_t max_size = cChunkDef::Width) -> std::uint8_t {
std::size_t alike_counter = 0;
const auto end = AxisIterator::end();
for (auto axis_crawl = AxisIterator(src_line, south_dir_mask); axis_crawl != end; axis_crawl++) {
@ -728,7 +723,7 @@ public:
//}
return alike_counter;
};
if (uint(src_block_loc.x + 1) < _size_in_power) { // only if we have room to check!
if (uint(src_block_loc.x + 1) < cChunkDef::Width) { // only if we have room to check!
const auto same_blocks_east_count = SearchLineEastForSameTypes();
block_quad_size.x = same_blocks_east_count;
std::cout << " Found blocks going east: " << (int)block_quad_size.x << std::endl;
@ -770,9 +765,9 @@ public:
return finished_quads;
}
static bool IsPosValidWithinChunk(ChunkVecType voxel_loc) {
if (voxel_loc.x >= _size_in_power)
if (voxel_loc.x >= cChunkDef::Width)
return false;
if (voxel_loc.y >= _size_in_power)
if (voxel_loc.y >= cChunkDef::Width)
return false;
return true;
}
@ -823,14 +818,14 @@ class QubelMeshingTestRenderingWindow : public CBaseWindow {
public:
const CTitleBar* titlebar;
const QubelMeshingTestWindow* settings;
Chunk world_slice;
FalseChunk world_slice;
class ChunkRenderer : public CBaseWidget {
public:
static constexpr std::pair<int, int> min_size = { 856, 480 };
const Chunk* world_slice;
const FalseChunk* world_slice;
const QubelMeshingTestWindow* settings;
ChunkRenderer(IWidget* parent, QubelMeshingTestWindow* settings, Chunk* world_slice)
ChunkRenderer(IWidget* parent, QubelMeshingTestWindow* settings, FalseChunk* world_slice)
: CBaseWidget("qubelmesh_test_renderer_sceneoutput", parent)
, world_slice(world_slice)
, settings(settings) {
@ -840,7 +835,7 @@ public:
});
this->SetSize(min_size.first, min_size.second);
}
std::vector<Chunk::ChunkMeshedQuad> current_render_quads;
std::vector<FalseChunk::ChunkMeshedQuad> current_render_quads;
virtual void Draw(ICanvas* the_drawing_machine) override {
this->CBaseWidget::Draw(the_drawing_machine);
const auto ConvertGLMVecToSTDPairVec = [](const geo::Vec2& vec_in) -> std::pair<int, int> {
@ -849,10 +844,10 @@ public:
const auto ConvertGLMQuadToSTDPairQuad = [&](const geo::Box<geo::Vec2>& box_in) -> Canvas::TranslationMatrix {
return Canvas::TranslationMatrix(ConvertGLMVecToSTDPairVec(box_in.origin), ConvertGLMVecToSTDPairVec(box_in.GetSize()));
};
for (const Chunk::ChunkMeshedQuad& kinda_a_vert : current_render_quads)
for (const FalseChunk::ChunkMeshedQuad& kinda_a_vert : current_render_quads)
the_drawing_machine->Rect(ConvertGLMQuadToSTDPairQuad(kinda_a_vert.quad), kinda_a_vert.clr);
if (this->settings->wireframe->Value()) {
for (const Chunk::ChunkMeshedQuad& kinda_a_vert : current_render_quads) {
for (const FalseChunk::ChunkMeshedQuad& kinda_a_vert : current_render_quads) {
the_drawing_machine->Rect({ ConvertGLMQuadToSTDPairQuad(kinda_a_vert.quad) }, glez::color::black, Canvas::RectType::Outline);
the_drawing_machine->Line({ ConvertGLMQuadToSTDPairQuad(kinda_a_vert.quad) }, glez::color::black);
}
@ -861,10 +856,10 @@ public:
virtual void Update() override {
this->CBaseWidget::Update();
if (current_render_quads.empty()) {
current_render_quads = world_slice->MeshChunk(Chunk::MesherComplexity(settings->dropdown->Value()));
current_render_quads = world_slice->MeshChunk(FalseChunk::MesherComplexity(settings->dropdown->Value()));
std::pair<int, int> found_size;
for (const Chunk::ChunkMeshedQuad& kinda_a_vert : current_render_quads) {
for (const FalseChunk::ChunkMeshedQuad& kinda_a_vert : current_render_quads) {
const auto max_coord = kinda_a_vert.quad.GetMax();
if (max_coord.x > found_size.first)
found_size.first = max_coord.x;