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