Aurailus
/
Zepha
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Optimize Chunk serialization format slightly.

master
Nicole Collings 2020-06-22 18:27:27 -07:00
parent b272721fed
commit d268654259
9 changed files with 278 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.idea/vcs.xml
View File

@ -2,6 +2,5 @@
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$" vcs="Git" />
<mapping directory="$PROJECT_DIR$/zepha-venus" vcs="Git" />
</component>
</project>

2
assets/shader/post/deferredLighting.fs
View File

@ -20,7 +20,7 @@ void main() {
float ssao = texture(ssaoSampler, texCoords).r;
//Shade based on Normals
float shading = (0.8 + abs(normal.x) * 0.15) + (normal.y * 0.15) + 0.2;
float shading = (0.95 + abs(normal.x) * 0.1) + (normal.y * 0.15);
color *= vec3(shading);
vec3 lighting = color;

42
src/util/net/Deserializer.h
View File

@ -121,51 +121,65 @@ template <> inline glm::ivec3 Deserializer::read<glm::ivec3>() {
template <> inline std::vector<int> Deserializer::read<std::vector<int>>() {
unsigned int len = read<unsigned int>();
auto oldInd = ind;
ind += len * 4;
return std::vector<int>(
reinterpret_cast<const int*>(&data[ind]),
reinterpret_cast<const int*>(&data[ind + len * 4]));
reinterpret_cast<const int*>(&data[oldInd]),
reinterpret_cast<const int*>(&data[ind]));
}
template <> inline std::vector<unsigned int> Deserializer::read<std::vector<unsigned int>>() {
unsigned int len = read<unsigned int>();
auto oldInd = ind;
ind += len * 4;
return std::vector<unsigned int>(
reinterpret_cast<const unsigned int*>(&data[ind]),
reinterpret_cast<const unsigned int*>(&data[ind + len * 4]));
reinterpret_cast<const unsigned int*>(&data[oldInd]),
reinterpret_cast<const unsigned int*>(&data[ind]));
}
template <> inline std::vector<short> Deserializer::read<std::vector<short>>() {
unsigned int len = read<unsigned int>();
auto oldInd = ind;
ind += len * 2;
return std::vector<short>(
reinterpret_cast<const short*>(&data[ind]),
reinterpret_cast<const short*>(&data[ind + len * 2]));
reinterpret_cast<const short*>(&data[oldInd]),
reinterpret_cast<const short*>(&data[ind]));
}
template <> inline std::vector<unsigned short> Deserializer::read<std::vector<unsigned short>>() {
unsigned int len = read<unsigned int>();
auto oldInd = ind;
ind += len * 2;
return std::vector<unsigned short>(
reinterpret_cast<const unsigned short*>(&data[ind]),
reinterpret_cast<const unsigned short*>(&data[ind + len * 2]));
reinterpret_cast<const unsigned short*>(&data[oldInd]),
reinterpret_cast<const unsigned short*>(&data[ind]));
}
template <> inline std::vector<char> Deserializer::read<std::vector<char>>() {
unsigned int len = read<unsigned int>();
auto oldInd = ind;
ind += len;
return std::vector<char>(
reinterpret_cast<const char*>(&data[ind]),
reinterpret_cast<const char*>(&data[ind + len]));
reinterpret_cast<const char*>(&data[oldInd]),
reinterpret_cast<const char*>(&data[ind]));
}
template <> inline std::vector<unsigned char> Deserializer::read<std::vector<unsigned char>>() {
unsigned int len = read<unsigned int>();
auto oldInd = ind;
ind += len;
return std::vector<unsigned char>(
reinterpret_cast<const unsigned char*>(&data[ind]),
reinterpret_cast<const unsigned char*>(&data[ind + len]));
reinterpret_cast<const unsigned char*>(&data[oldInd]),
reinterpret_cast<const unsigned char*>(&data[ind]));
}
template <> inline std::vector<float> Deserializer::read<std::vector<float>>() {
unsigned int len = read<unsigned int>();
auto oldInd = ind;
ind += len * 4;
return std::vector<float>(
reinterpret_cast<const float*>(&data[ind]),
reinterpret_cast<const float*>(&data[ind + len * 4]));
reinterpret_cast<const float*>(&data[oldInd]),
reinterpret_cast<const float*>(&data[ind]));
}
template <> inline std::vector<std::string> Deserializer::read<std::vector<std::string>>() {

52
src/world/chunk/Chunk.cpp
View File

@ -47,15 +47,6 @@ const std::vector<unsigned short> &Chunk::cGetBiomes() const {
}
Packet Chunk::serialize() {
Serializer s;
s.append(pos);
std::string temp = Serializer().append(blocks).data;
s.append<std::string>(gzip::compress(temp.data(), temp.size()));
temp = Serializer().append(biomes).data;
s.append<std::string>(gzip::compress(temp.data(), temp.size()));
std::vector<unsigned char> lights {};
lights.resize(4096 * 4);
for (unsigned short i = 0; i < 4096; i++) {
@ -64,40 +55,35 @@ Packet Chunk::serialize() {
lights[i * 4 + 2] = blocklight[i].b;
lights[i * 4 + 3] = getSunlight(i);
}
temp = Serializer().append(lights).data;
Serializer s;
std::string temp = Serializer().append(pos).append(blocks).append(biomes).append(lights).data;
s.append<std::string>(gzip::compress(temp.data(), temp.size()));
std::cout << s.data.length() << std::endl;
return s.packet(PacketType::CHUNK);
}
void Chunk::deserialize(PacketView& packet) {
// pos = packet.d.read<glm::ivec3>();
pos = packet.d.read<glm::ivec3>();
std::string gzipped = packet.d.read<std::string>();
if (!gzip::is_compressed(gzipped.data(), gzipped.length())) throw "Invalid Blocks GZip Data.";
auto light = Deserializer(gzip::decompress(gzipped.data(), gzipped.length()))
.read<glm::ivec3>(pos)
.read<std::vector<unsigned int>>(blocks)
.read<std::vector<unsigned short>>(biomes)
.read<std::vector<unsigned char>>();
auto gzip = packet.d.read<std::string>();
if (!gzip::is_compressed(gzip.data(), gzip.length())) throw "Invalid Blocks GZip Data.";
gzip = gzip::decompress(gzip.data(), gzip.length());
blocks = Deserializer(gzip).read<std::vector<unsigned int>>();
recalculateRenderableBlocks();
gzip = packet.d.read<std::string>();
if (!gzip::is_compressed(gzip.data(), gzip.length())) throw "Invalid Biomes GZip Data.";
gzip = gzip::decompress(gzip.data(), gzip.length());
biomes = Deserializer(gzip).read<std::vector<unsigned short>>();
gzip = packet.d.read<std::string>();
if (!gzip::is_compressed(gzip.data(), gzip.length())) throw "Invalid Light GZip Data.";
gzip = gzip::decompress(gzip.data(), gzip.length());
auto lightsVec = Deserializer(gzip).read<std::vector<unsigned char>>();
for (unsigned int i = 0; i < 4096; i++) {
blocklight[i].r = lightsVec[i * 4];
blocklight[i].g = lightsVec[i * 4 + 1];
blocklight[i].b = lightsVec[i * 4 + 2];
setSunlight(i, lightsVec[i * 4 + 3]);
blocklight[i].r = light[i * 4];
blocklight[i].g = light[i * 4 + 1];
blocklight[i].b = light[i * 4 + 2];
setSunlight(i, light[i * 4 + 3]);
}
recalculateRenderableBlocks();
}
void Chunk::recalculateRenderableBlocks() {

2
test/CMakeLists.txt
View File

@ -1,4 +1,4 @@
set(ZEPHA_TEST
Main.cpp tests/TestSpace.cpp tests/TestBlockChunk.cpp tests/TestSerializer.cpp)
Main.cpp tests/TestSpace.cpp tests/TestBlockChunk.cpp tests/TestSerializer.cpp tests/TestBlockChunkSerialization.cpp)
add_library (Zepha_Test ${ZEPHA_TEST})

3
test/Main.cpp
View File

@ -13,4 +13,5 @@ TEST_CASE("Catch2 Library", "[core]") {
#include "tests/TestSpace.cpp"
#include "tests/TestBlockChunk.cpp"
#include "tests/TestSerializer.cpp"
#include "tests/TestSerializer.cpp"
#include "tests/TestBlockChunkSerialization.cpp"

71
test/tests/TestBlockChunk.cpp
View File

@ -10,44 +10,43 @@
#pragma ide diagnostic ignored "OCUnusedGlobalDeclarationInspection"
TEST_CASE("Chunk", "[engine]") {
// SECTION("Lighting") {
// Chunk b;
//
// b.setSunlight(1, 4);
// b.setSunlight(2, 1);
// b.setSunlight(3, 11);
// b.setSunlight(4, 5);
// b.setSunlight(100, 15);
// b.setSunlight(3000, 0);
//
// b.setBlocklight(1, 4);
// b.setBlocklight(2, 1);
// b.setBlocklight(3, 11);
// b.setBlocklight(4, 5);
// b.setBlocklight(100, 15);
// b.setBlocklight(3000, 0);
//
// SECTION("Sunlight") {
// REQUIRE(b.getSunlight(1) == 4);
// REQUIRE(b.getSunlight(2) == 1);
// REQUIRE(b.getSunlight(3) == 11);
// REQUIRE(b.getSunlight(4) == 5);
// REQUIRE(b.getSunlight(100) == 15);
// REQUIRE(b.getSunlight(3000) == 0);
// }
//
// SECTION("Blocklight") {
// REQUIRE(b.getBlocklight(1) == 4);
// REQUIRE(b.getBlocklight(2) == 1);
// REQUIRE(b.getBlocklight(3) == 11);
// REQUIRE(b.getBlocklight(4) == 5);
// REQUIRE(b.getBlocklight(100) == 15);
// REQUIRE(b.getBlocklight(3000) == 0);
// }
// }
SECTION("Lighting") {
Chunk b;
b.setLight(1, 3, 4);
b.setLight(2, 3, 1);
b.setLight(3, 3, 11);
b.setLight(4, 3, 5);
b.setLight(100, 3, 15);
b.setLight(3000, 3, 0);
b.setLight(1, 0, 4);
b.setLight(2, 0, 1);
b.setLight(3, 1, 11);
b.setLight(4, 1, 5);
b.setLight(100, 2, 15);
b.setLight(3000, 2, 0);
SECTION("Sunlight") {
REQUIRE(b.getLight(1, 3) == 4);
REQUIRE(b.getLight(2, 3) == 1);
REQUIRE(b.getLight(3, 3) == 11);
REQUIRE(b.getLight(4, 3) == 5);
REQUIRE(b.getLight(100, 3) == 15);
REQUIRE(b.getLight(3000, 3) == 0);
}
SECTION("Blocklight") {
REQUIRE(b.getLight(1, 0) == 4);
REQUIRE(b.getLight(2, 0) == 1);
REQUIRE(b.getLight(3, 1) == 11);
REQUIRE(b.getLight(4, 1) == 5);
REQUIRE(b.getLight(100, 2) == 15);
REQUIRE(b.getLight(3000, 2) == 0);
}
}
SECTION("Blocks") {
SECTION("Exact index = 0, strip one after") {
Chunk b {{0, 1, 1, 0}, {}};

34
test/tests/TestBlockChunkSerialization.cpp Normal file
View File

@ -0,0 +1,34 @@
//
// Created by aurailus on 2020-06-21.
//
#include <catch2/catch.hpp>
#include "../../src/world/chunk/Chunk.h"
#pragma clang diagnostic push
#pragma ide diagnostic ignored "OCUnusedGlobalDeclarationInspection"
TEST_CASE("Chunk Serialization", "[net]") {
Chunk a = Chunk();
a.setBlock(5, 20);
a.setBlock(6, 0);
a.setBlock(8, 3);
a.setBlock(9, 3);
Packet packet(PacketType::CHUNK);
packet.data = a.serialize();
ENetPacket* enet = packet.toENetPacket();
PacketView view(enet);
Chunk b = Chunk();
std::string s(view.d.data + 4, view.d.data + view.d.len);
b.deserialize(s);
auto itA = a.cGetBlocks();
auto itB = b.cGetBlocks();
for (unsigned int i = 0; i < itA.size(); i++) REQUIRE(itA[i] == itB[i]);
}
#pragma clang diagnostic pop

319
test/tests/TestSpace.cpp
View File

@ -6,46 +6,43 @@
#include <iostream>
#include "../../src/util/Space.h"
using namespace Space;
using namespace glm;
TEST_CASE("Space", "[math]") {
SECTION("Region") {
SECTION("World") {
SECTION("From Map Block") {
REQUIRE(Region::world::fromMapBlock({0, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(Region::world::fromMapBlock({1, 1, 1}) == ivec3 {0, 0, 0});
REQUIRE(Region::world::fromMapBlock({3, 1, 1}) == ivec3 {0, 0, 0});
REQUIRE(Region::world::fromMapBlock({1, 5, 1}) == ivec3 {0, 1, 0});
REQUIRE(Region::world::fromMapBlock({1, 1, 10}) == ivec3 {0, 0, 2});
REQUIRE(Region::world::fromMapBlock({0, -1, 0}) == ivec3 {0, -1, 0});
REQUIRE(Region::world::fromMapBlock({-3, -5, -4}) == ivec3 {-1, -2, -1});
REQUIRE(Region::world::fromMapBlock({-8, -9, -15}) == ivec3 {-2, -3, -4});
REQUIRE(Region::world::fromMapBlock({13, 60, -4}) == ivec3 {3, 15, -1});
REQUIRE(Space::Region::world::fromMapBlock({0, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Region::world::fromMapBlock({1, 1, 1}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Region::world::fromMapBlock({3, 1, 1}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Region::world::fromMapBlock({1, 5, 1}) == glm::ivec3 {0, 1, 0});
REQUIRE(Space::Region::world::fromMapBlock({1, 1, 10}) == glm::ivec3 {0, 0, 2});
REQUIRE(Space::Region::world::fromMapBlock({0, -1, 0}) == glm::ivec3 {0, -1, 0});
REQUIRE(Space::Region::world::fromMapBlock({-3, -5, -4}) == glm::ivec3 {-1, -2, -1});
REQUIRE(Space::Region::world::fromMapBlock({-8, -9, -15}) == glm::ivec3 {-2, -3, -4});
REQUIRE(Space::Region::world::fromMapBlock({13, 60, -4}) == glm::ivec3 {3, 15, -1});
}
SECTION("From Chunk") {
REQUIRE(Region::world::fromChunk(vec3 {0, 0, 0} * static_cast<float>(MAPBLOCK_SIZE)) == ivec3 {0, 0, 0});
REQUIRE(Region::world::fromChunk(vec3 {1, 1, 1} * static_cast<float>(MAPBLOCK_SIZE)) == ivec3 {0, 0, 0});
REQUIRE(Region::world::fromChunk(vec3 {3, 1, 1} * static_cast<float>(MAPBLOCK_SIZE)) == ivec3 {0, 0, 0});
REQUIRE(Region::world::fromChunk(vec3 {1, 5, 1} * static_cast<float>(MAPBLOCK_SIZE)) == ivec3 {0, 1, 0});
REQUIRE(Region::world::fromChunk(vec3 {1, 1, 10} * static_cast<float>(MAPBLOCK_SIZE)) == ivec3 {0, 0, 2});
REQUIRE(Region::world::fromChunk(vec3 {0, -1, 0} * static_cast<float>(MAPBLOCK_SIZE)) == ivec3 {0, -1, 0});
REQUIRE(Region::world::fromChunk(vec3 {-3, -5, -4} * static_cast<float>(MAPBLOCK_SIZE)) == ivec3 {-1, -2, -1});
REQUIRE(Region::world::fromChunk(vec3 {-8, -9, -15} * static_cast<float>(MAPBLOCK_SIZE)) == ivec3 {-2, -3, -4});
REQUIRE(Region::world::fromChunk(vec3 {13, 60, -4} * static_cast<float>(MAPBLOCK_SIZE)) == ivec3 {3, 15, -1});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {0, 0, 0} * Space::MAPBLOCK_SIZE) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {1, 1, 1} * Space::MAPBLOCK_SIZE) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {3, 1, 1} * Space::MAPBLOCK_SIZE) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {1, 5, 1} * Space::MAPBLOCK_SIZE) == glm::ivec3 {0, 1, 0});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {1, 1, 10} * Space::MAPBLOCK_SIZE) == glm::ivec3 {0, 0, 2});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {0, -1, 0} * Space::MAPBLOCK_SIZE) == glm::ivec3 {0, -1, 0});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {-3, -5, -4} * Space::MAPBLOCK_SIZE) == glm::ivec3 {-1, -2, -1});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {-8, -9, -15} * Space::MAPBLOCK_SIZE) == glm::ivec3 {-2, -3, -4});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {13, 60, -4} * Space::MAPBLOCK_SIZE) == glm::ivec3 {3, 15, -1});
}
SECTION("From Block") {
REQUIRE(Region::world::fromChunk(vec3 {0, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(Region::world::fromChunk(vec3 {4, 4, 4}) == ivec3 {0, 0, 0});
REQUIRE(Region::world::fromChunk(vec3 {12, 4, 4}) == ivec3 {0, 0, 0});
REQUIRE(Region::world::fromChunk(vec3 {4, 20, 4}) == ivec3 {0, 1, 0});
REQUIRE(Region::world::fromChunk(vec3 {4, 4, 40}) == ivec3 {0, 0, 2});
REQUIRE(Region::world::fromChunk(vec3 {0, -4, 0}) == ivec3 {0, -1, 0});
REQUIRE(Region::world::fromChunk(vec3 {-12, -20, -16}) == ivec3 {-1, -2, -1});
REQUIRE(Region::world::fromChunk(vec3 {-32, -36, -60}) == ivec3 {-2, -3, -4});
REQUIRE(Region::world::fromChunk(vec3 {52, 240, -16}) == ivec3 {3, 15, -1});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {0, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {4, 4, 4}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {12, 4, 4}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {4, 20, 4}) == glm::ivec3 {0, 1, 0});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {4, 4, 40}) == glm::ivec3 {0, 0, 2});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {0, -4, 0}) == glm::ivec3 {0, -1, 0});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {-12, -20, -16}) == glm::ivec3 {-1, -2, -1});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {-32, -36, -60}) == glm::ivec3 {-2, -3, -4});
REQUIRE(Space::Region::world::fromChunk(glm::ivec3 {52, 240, -16}) == glm::ivec3 {3, 15, -1});
}
}
}
@ -53,177 +50,177 @@ TEST_CASE("Space", "[math]") {
SECTION("MapBlock") {
SECTION("Relative") {
SECTION("To Region") {
REQUIRE(MapBlock::relative::toRegion({0, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(MapBlock::relative::toRegion({0, 5, 0}) == ivec3 {0, 1, 0});
REQUIRE(MapBlock::relative::toRegion({5, 20, 0}) == ivec3 {1, 0, 0});
REQUIRE(MapBlock::relative::toRegion({40, 20, 30}) == ivec3 {0, 0, 2});
REQUIRE(MapBlock::relative::toRegion({0, -5, 0}) == ivec3 {0, 3, 0});
REQUIRE(MapBlock::relative::toRegion({-10, -7, -3}) == ivec3 {2, 1, 1});
REQUIRE(MapBlock::relative::toRegion({-16, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(MapBlock::relative::toRegion({-17, -18, -19}) == ivec3 {3, 2, 1});
REQUIRE(Space::MapBlock::relative::toRegion({0, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::MapBlock::relative::toRegion({0, 5, 0}) == glm::ivec3 {0, 1, 0});
REQUIRE(Space::MapBlock::relative::toRegion({5, 20, 0}) == glm::ivec3 {1, 0, 0});
REQUIRE(Space::MapBlock::relative::toRegion({40, 20, 30}) == glm::ivec3 {0, 0, 2});
REQUIRE(Space::MapBlock::relative::toRegion({0, -5, 0}) == glm::ivec3 {0, 3, 0});
REQUIRE(Space::MapBlock::relative::toRegion({-10, -7, -3}) == glm::ivec3 {2, 1, 1});
REQUIRE(Space::MapBlock::relative::toRegion({-16, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::MapBlock::relative::toRegion({-17, -18, -19}) == glm::ivec3 {3, 2, 1});
}
}
SECTION("World") {
SECTION("From Chunk") {
REQUIRE(MapBlock::world::fromChunk({0, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(MapBlock::world::fromChunk({1, 1, 1}) == ivec3 {0, 0, 0});
REQUIRE(MapBlock::world::fromChunk({3, 1, 1}) == ivec3 {0, 0, 0});
REQUIRE(MapBlock::world::fromChunk({1, 5, 1}) == ivec3 {0, 1, 0});
REQUIRE(MapBlock::world::fromChunk({1, 1, 10}) == ivec3 {0, 0, 2});
REQUIRE(MapBlock::world::fromChunk({0, -1, 0}) == ivec3 {0, -1, 0});
REQUIRE(MapBlock::world::fromChunk({-3, -5, -4}) == ivec3 {-1, -2, -1});
REQUIRE(MapBlock::world::fromChunk({-8, -9, -15}) == ivec3 {-2, -3, -4});
REQUIRE(MapBlock::world::fromChunk({13, 60, -4}) == ivec3 {3, 15, -1});
REQUIRE(Space::MapBlock::world::fromChunk({0, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::MapBlock::world::fromChunk({1, 1, 1}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::MapBlock::world::fromChunk({3, 1, 1}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::MapBlock::world::fromChunk({1, 5, 1}) == glm::ivec3 {0, 1, 0});
REQUIRE(Space::MapBlock::world::fromChunk({1, 1, 10}) == glm::ivec3 {0, 0, 2});
REQUIRE(Space::MapBlock::world::fromChunk({0, -1, 0}) == glm::ivec3 {0, -1, 0});
REQUIRE(Space::MapBlock::world::fromChunk({-3, -5, -4}) == glm::ivec3 {-1, -2, -1});
REQUIRE(Space::MapBlock::world::fromChunk({-8, -9, -15}) == glm::ivec3 {-2, -3, -4});
REQUIRE(Space::MapBlock::world::fromChunk({13, 60, -4}) == glm::ivec3 {3, 15, -1});
}
SECTION("From Block") {
REQUIRE(MapBlock::world::fromBlock({0, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(MapBlock::world::fromBlock({16, 16, 16}) == ivec3 {0, 0, 0});
REQUIRE(MapBlock::world::fromBlock({48, 16, 16}) == ivec3 {0, 0, 0});
REQUIRE(MapBlock::world::fromBlock({16, 80, 16}) == ivec3 {0, 1, 0});
REQUIRE(MapBlock::world::fromBlock({16, 16, 160}) == ivec3 {0, 0, 2});
REQUIRE(MapBlock::world::fromBlock({0, -16, 0}) == ivec3 {0, -1, 0});
REQUIRE(MapBlock::world::fromBlock({-48, -80, -64}) == ivec3 {-1, -2, -1});
REQUIRE(MapBlock::world::fromBlock({-128, -144, -240}) == ivec3 {-2, -3, -4});
REQUIRE(MapBlock::world::fromBlock({208, 960, -64}) == ivec3 {3, 15, -1});
REQUIRE(Space::MapBlock::world::fromBlock({0, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::MapBlock::world::fromBlock({16, 16, 16}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::MapBlock::world::fromBlock({48, 16, 16}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::MapBlock::world::fromBlock({16, 80, 16}) == glm::ivec3 {0, 1, 0});
REQUIRE(Space::MapBlock::world::fromBlock({16, 16, 160}) == glm::ivec3 {0, 0, 2});
REQUIRE(Space::MapBlock::world::fromBlock({0, -16, 0}) == glm::ivec3 {0, -1, 0});
REQUIRE(Space::MapBlock::world::fromBlock({-48, -80, -64}) == glm::ivec3 {-1, -2, -1});
REQUIRE(Space::MapBlock::world::fromBlock({-128, -144, -240}) == glm::ivec3 {-2, -3, -4});
REQUIRE(Space::MapBlock::world::fromBlock({208, 960, -64}) == glm::ivec3 {3, 15, -1});
}
}
SECTION("Index") {
REQUIRE(MapBlock::index({0, 0, 0}) == 0);
REQUIRE(MapBlock::index({0, 5, 0}) == 4);
REQUIRE(MapBlock::index({5, 20, 0}) == 1);
REQUIRE(MapBlock::index({40, 20, 30}) == 32);
REQUIRE(MapBlock::index({0, -5, 0}) == 12);
REQUIRE(MapBlock::index({-10, -7, -3}) == 22);
REQUIRE(MapBlock::index({-16, 0, 0}) == 0);
REQUIRE(MapBlock::index({3, 3, 3}) == 63);
REQUIRE(MapBlock::index({0, 0, 0}) == Chunk::index({0, 0, 0}));
REQUIRE(MapBlock::index({0, 5, 0}) == Chunk::index({0, 1, 0}));
REQUIRE(MapBlock::index({5, 20, 0}) == Chunk::index({1, 0, 0}));
REQUIRE(MapBlock::index({40, 20, 30}) == Chunk::index({0, 0, 2}));
REQUIRE(MapBlock::index({0, -5, 0}) == Chunk::index({0, 3, 0}));
REQUIRE(MapBlock::index({-10, -7, -3}) == Chunk::index({2, 1, 1}));
REQUIRE(MapBlock::index({-16, 0, 0}) == Chunk::index({0, 0, 0}));
REQUIRE(MapBlock::index({-17, -18, -19}) == Chunk::index({3, 2, 1}));
}
// SECTION("Index") {
// REQUIRE(Space::MapBlock::index({0, 0, 0}) == 0);
// REQUIRE(Space::MapBlock::index({0, 5, 0}) == 4);
// REQUIRE(Space::MapBlock::index({5, 20, 0}) == 1);
// REQUIRE(Space::MapBlock::index({40, 20, 30}) == 32);
// REQUIRE(Space::MapBlock::index({0, -5, 0}) == 12);
// REQUIRE(Space::MapBlock::index({-10, -7, -3}) == 22);
// REQUIRE(Space::MapBlock::index({-16, 0, 0}) == 0);
// REQUIRE(Space::MapBlock::index({3, 3, 3}) == 63);
//
// REQUIRE(Space::MapBlock::index({0, 0, 0}) == Space::Chunk::index({0, 0, 0}));
// REQUIRE(Space::MapBlock::index({0, 5, 0}) == Space::Chunk::index({0, 1, 0}));
// REQUIRE(Space::MapBlock::index({5, 20, 0}) == Space::Chunk::index({1, 0, 0}));
// REQUIRE(Space::MapBlock::index({40, 20, 30}) == Space::Chunk::index({0, 0, 2}));
// REQUIRE(Space::MapBlock::index({0, -5, 0}) == Space::Chunk::index({0, 3, 0}));
// REQUIRE(Space::MapBlock::index({-10, -7, -3}) == Space::Chunk::index({2, 1, 1}));
// REQUIRE(Space::MapBlock::index({-16, 0, 0}) == Space::Chunk::index({0, 0, 0}));
// REQUIRE(Space::MapBlock::index({-17, -18, -19}) == Space::Chunk::index({3, 2, 1}));
// }
}
SECTION("Chunk") {
SECTION("Relative") {
SECTION("To Map Block") {
REQUIRE(Chunk::relative::toMapBlock({0, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(Chunk::relative::toMapBlock({0, 5, 0}) == ivec3 {0, 1, 0});
REQUIRE(Chunk::relative::toMapBlock({5, 20, 0}) == ivec3 {1, 0, 0});
REQUIRE(Chunk::relative::toMapBlock({40, 20, 30}) == ivec3 {0, 0, 2});
REQUIRE(Chunk::relative::toMapBlock({0, -5, 0}) == ivec3 {0, 3, 0});
REQUIRE(Chunk::relative::toMapBlock({-10, -7, -3}) == ivec3 {2, 1, 1});
REQUIRE(Chunk::relative::toMapBlock({-16, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(Chunk::relative::toMapBlock({-17, -18, -19}) == ivec3 {3, 2, 1});
REQUIRE(Space::Chunk::relative::toMapBlock({0, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Chunk::relative::toMapBlock({0, 5, 0}) == glm::ivec3 {0, 1, 0});
REQUIRE(Space::Chunk::relative::toMapBlock({5, 20, 0}) == glm::ivec3 {1, 0, 0});
REQUIRE(Space::Chunk::relative::toMapBlock({40, 20, 30}) == glm::ivec3 {0, 0, 2});
REQUIRE(Space::Chunk::relative::toMapBlock({0, -5, 0}) == glm::ivec3 {0, 3, 0});
REQUIRE(Space::Chunk::relative::toMapBlock({-10, -7, -3}) == glm::ivec3 {2, 1, 1});
REQUIRE(Space::Chunk::relative::toMapBlock({-16, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Chunk::relative::toMapBlock({-17, -18, -19}) == glm::ivec3 {3, 2, 1});
}
SECTION("To Region") {
REQUIRE(Chunk::relative::toRegion({0, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(Chunk::relative::toRegion({0, 5, 0}) == ivec3 {0, 5, 0});
REQUIRE(Chunk::relative::toRegion({5, 20, 0}) == ivec3 {5, 4, 0});
REQUIRE(Chunk::relative::toRegion({40, 20, 30}) == ivec3 {8, 4, 14});
REQUIRE(Chunk::relative::toRegion({0, -5, 0}) == ivec3 {0, 11, 0});
REQUIRE(Chunk::relative::toRegion({-10, -7, -3}) == ivec3 {6, 9, 13});
REQUIRE(Chunk::relative::toRegion({-16, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(Chunk::relative::toRegion({-17, -18, -19}) == ivec3 {15, 14, 13});
REQUIRE(Space::Chunk::relative::toRegion({0, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Chunk::relative::toRegion({0, 5, 0}) == glm::ivec3 {0, 5, 0});
REQUIRE(Space::Chunk::relative::toRegion({5, 20, 0}) == glm::ivec3 {5, 4, 0});
REQUIRE(Space::Chunk::relative::toRegion({40, 20, 30}) == glm::ivec3 {8, 4, 14});
REQUIRE(Space::Chunk::relative::toRegion({0, -5, 0}) == glm::ivec3 {0, 11, 0});
REQUIRE(Space::Chunk::relative::toRegion({-10, -7, -3}) == glm::ivec3 {6, 9, 13});
REQUIRE(Space::Chunk::relative::toRegion({-16, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Chunk::relative::toRegion({-17, -18, -19}) == glm::ivec3 {15, 14, 13});
}
}
SECTION("World") {
SECTION("From Block") {
REQUIRE(Chunk::world::fromBlock({0, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(Chunk::world::fromBlock({5, 17, 8}) == ivec3 {0, 1, 0});
REQUIRE(Chunk::world::fromBlock({23, 0, 3}) == ivec3 {1, 0, 0});
REQUIRE(Chunk::world::fromBlock({0, 0, 32}) == ivec3 {0, 0, 2});
REQUIRE(Chunk::world::fromBlock({-4, 40, 0}) == ivec3 {-1, 2, 0});
REQUIRE(Chunk::world::fromBlock({-17, -16, -15}) == ivec3 {-2, -1, -1});
REQUIRE(Chunk::world::fromBlock({-35, -30, -64}) == ivec3 {-3, -2, -4});
REQUIRE(Chunk::world::fromBlock({36, 64, -12}) == ivec3 {2, 4, -1});
REQUIRE(Space::Chunk::world::fromBlock({0, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Chunk::world::fromBlock({5, 17, 8}) == glm::ivec3 {0, 1, 0});
REQUIRE(Space::Chunk::world::fromBlock({23, 0, 3}) == glm::ivec3 {1, 0, 0});
REQUIRE(Space::Chunk::world::fromBlock({0, 0, 32}) == glm::ivec3 {0, 0, 2});
REQUIRE(Space::Chunk::world::fromBlock({-4, 40, 0}) == glm::ivec3 {-1, 2, 0});
REQUIRE(Space::Chunk::world::fromBlock({-17, -16, -15}) == glm::ivec3 {-2, -1, -1});
REQUIRE(Space::Chunk::world::fromBlock({-35, -30, -64}) == glm::ivec3 {-3, -2, -4});
REQUIRE(Space::Chunk::world::fromBlock({36, 64, -12}) == glm::ivec3 {2, 4, -1});
}
}
SECTION("Index") {
REQUIRE(Chunk::index({0, 0, 0}) == 0);
REQUIRE(Chunk::index({0, 5, 0}) == 4);
REQUIRE(Chunk::index({5, 20, 0}) == 1);
REQUIRE(Chunk::index({40, 20, 30}) == 32);
REQUIRE(Chunk::index({0, -5, 0}) == 12);
REQUIRE(Chunk::index({-10, -7, -3}) == 22);
REQUIRE(Chunk::index({-16, 0, 0}) == 0);
REQUIRE(Chunk::index({3, 3, 3}) == 63);
REQUIRE(Chunk::index({0, 0, 0}) == Chunk::index({0, 0, 0}));
REQUIRE(Chunk::index({0, 5, 0}) == Chunk::index({0, 1, 0}));
REQUIRE(Chunk::index({5, 20, 0}) == Chunk::index({1, 0, 0}));
REQUIRE(Chunk::index({40, 20, 30}) == Chunk::index({0, 0, 2}));
REQUIRE(Chunk::index({0, -5, 0}) == Chunk::index({0, 3, 0}));
REQUIRE(Chunk::index({-10, -7, -3}) == Chunk::index({2, 1, 1}));
REQUIRE(Chunk::index({-16, 0, 0}) == Chunk::index({0, 0, 0}));
REQUIRE(Chunk::index({-17, -18, -19}) == Chunk::index({3, 2, 1}));
}
// SECTION("Index") {
// REQUIRE(Space::Chunk::index({0, 0, 0}) == 0);
// REQUIRE(Space::Chunk::index({0, 5, 0}) == 4);
// REQUIRE(Space::Chunk::index({5, 20, 0}) == 1);
// REQUIRE(Space::Chunk::index({40, 20, 30}) == 32);
// REQUIRE(Space::Chunk::index({0, -5, 0}) == 12);
// REQUIRE(Space::Chunk::index({-10, -7, -3}) == 22);
// REQUIRE(Space::Chunk::index({-16, 0, 0}) == 0);
// REQUIRE(Space::Chunk::index({3, 3, 3}) == 63);
//
// REQUIRE(Space::Chunk::index({0, 0, 0}) == Space::Chunk::index({0, 0, 0}));
// REQUIRE(Space::Chunk::index({0, 5, 0}) == Space::Chunk::index({0, 1, 0}));
// REQUIRE(Space::Chunk::index({5, 20, 0}) == Space::Chunk::index({1, 0, 0}));
// REQUIRE(Space::Chunk::index({40, 20, 30}) == Space::Chunk::index({0, 0, 2}));
// REQUIRE(Space::Chunk::index({0, -5, 0}) == Space::Chunk::index({0, 3, 0}));
// REQUIRE(Space::Chunk::index({-10, -7, -3}) == Space::Chunk::index({2, 1, 1}));
// REQUIRE(Space::Chunk::index({-16, 0, 0}) == Space::Chunk::index({0, 0, 0}));
// REQUIRE(Space::Chunk::index({-17, -18, -19}) == Space::Chunk::index({3, 2, 1}));
// }
}
SECTION("Block") {
SECTION("Relative") {
SECTION("To Chunk") {
REQUIRE(Block::relative::toChunk({0, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(Block::relative::toChunk({0, 5, 0}) == ivec3 {0, 5, 0});
REQUIRE(Block::relative::toChunk({5, 20, 0}) == ivec3 {5, 4, 0});
REQUIRE(Block::relative::toChunk({40, 20, 30}) == ivec3 {8, 4, 14});
REQUIRE(Block::relative::toChunk({0, -5, 0}) == ivec3 {0, 11, 0});
REQUIRE(Block::relative::toChunk({-10, -7, -3}) == ivec3 {6, 9, 13});
REQUIRE(Block::relative::toChunk({-16, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(Block::relative::toChunk({-17, -18, -19}) == ivec3 {15, 14, 13});
REQUIRE(Space::Block::relative::toChunk({0, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Block::relative::toChunk({0, 5, 0}) == glm::ivec3 {0, 5, 0});
REQUIRE(Space::Block::relative::toChunk({5, 20, 0}) == glm::ivec3 {5, 4, 0});
REQUIRE(Space::Block::relative::toChunk({40, 20, 30}) == glm::ivec3 {8, 4, 14});
REQUIRE(Space::Block::relative::toChunk({0, -5, 0}) == glm::ivec3 {0, 11, 0});
REQUIRE(Space::Block::relative::toChunk({-10, -7, -3}) == glm::ivec3 {6, 9, 13});
REQUIRE(Space::Block::relative::toChunk({-16, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Block::relative::toChunk({-17, -18, -19}) == glm::ivec3 {15, 14, 13});
}
SECTION("To Map Block") {
REQUIRE(Block::relative::toMapBlock({0, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(Block::relative::toMapBlock({0, 5, 0}) == ivec3 {0, 5, 0});
REQUIRE(Block::relative::toMapBlock({5, 20, 0}) == ivec3 {5, 20, 0});
REQUIRE(Block::relative::toMapBlock({40, 20, 30}) == ivec3 {40, 20, 30});
REQUIRE(Block::relative::toMapBlock({0, -5, 0}) == ivec3 {0, 59, 0});
REQUIRE(Block::relative::toMapBlock({-10, -7, -3}) == ivec3 {54, 57, 61});
REQUIRE(Block::relative::toMapBlock({-16, 0, 0}) == ivec3 {48, 0, 0});
REQUIRE(Block::relative::toMapBlock({-17, -18, -19}) == ivec3 {47, 46, 45});
REQUIRE(Space::Block::relative::toMapBlock({0, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Block::relative::toMapBlock({0, 5, 0}) == glm::ivec3 {0, 5, 0});
REQUIRE(Space::Block::relative::toMapBlock({5, 20, 0}) == glm::ivec3 {5, 20, 0});
REQUIRE(Space::Block::relative::toMapBlock({40, 20, 30}) == glm::ivec3 {40, 20, 30});
REQUIRE(Space::Block::relative::toMapBlock({0, -5, 0}) == glm::ivec3 {0, 59, 0});
REQUIRE(Space::Block::relative::toMapBlock({-10, -7, -3}) == glm::ivec3 {54, 57, 61});
REQUIRE(Space::Block::relative::toMapBlock({-16, 0, 0}) == glm::ivec3 {48, 0, 0});
REQUIRE(Space::Block::relative::toMapBlock({-17, -18, -19}) == glm::ivec3 {47, 46, 45});
}
SECTION("To Region") {
REQUIRE(Block::relative::toRegion({0, 0, 0}) == ivec3 {0, 0, 0});
REQUIRE(Block::relative::toRegion({0, 5, 0}) == ivec3 {0, 5, 0});
REQUIRE(Block::relative::toRegion({5, 256, 0}) == ivec3 {5, 0, 0});
REQUIRE(Block::relative::toRegion({40, 20, 30}) == ivec3 {40, 20, 30});
REQUIRE(Block::relative::toRegion({0, -5, 0}) == ivec3 {0, 251, 0});
REQUIRE(Block::relative::toRegion({-10, -7, -3}) == ivec3 {246, 249, 253});
REQUIRE(Block::relative::toRegion({-16, 0, 0}) == ivec3 {240, 0, 0});
REQUIRE(Block::relative::toRegion({-17, -18, -19}) == ivec3 {239, 238, 237});
REQUIRE(Space::Block::relative::toRegion({0, 0, 0}) == glm::ivec3 {0, 0, 0});
REQUIRE(Space::Block::relative::toRegion({0, 5, 0}) == glm::ivec3 {0, 5, 0});
REQUIRE(Space::Block::relative::toRegion({5, 256, 0}) == glm::ivec3 {5, 0, 0});
REQUIRE(Space::Block::relative::toRegion({40, 20, 30}) == glm::ivec3 {40, 20, 30});
REQUIRE(Space::Block::relative::toRegion({0, -5, 0}) == glm::ivec3 {0, 251, 0});
REQUIRE(Space::Block::relative::toRegion({-10, -7, -3}) == glm::ivec3 {246, 249, 253});
REQUIRE(Space::Block::relative::toRegion({-16, 0, 0}) == glm::ivec3 {240, 0, 0});
REQUIRE(Space::Block::relative::toRegion({-17, -18, -19}) == glm::ivec3 {239, 238, 237});
}
}
SECTION("Index") {
REQUIRE(Block::index({0, 0, 0}) == 0);
REQUIRE(Block::index({0, 5, 0}) == 80);
REQUIRE(Block::index({5, 20, 0}) == 69);
REQUIRE(Block::index({40, 20, 30}) == 3656);
REQUIRE(Block::index({0, -5, 0}) == 176);
REQUIRE(Block::index({-10, -7, -3}) == 3478);
REQUIRE(Block::index({-16, 0, 0}) == 0);
REQUIRE(Block::index({3, 3, 3}) == 819);
REQUIRE(Block::index({0, 0, 0}) == Block::index({0, 0, 0}));
REQUIRE(Block::index({0, 17, 0}) == Block::index({0, 1, 0}));
REQUIRE(Block::index({18, 32, 0}) == Block::index({2, 0, 0}));
REQUIRE(Block::index({40, 20, 30}) == Block::index({8, 4, 14}));
REQUIRE(Block::index({0, -5, 0}) == Block::index({0, 11, 0}));
REQUIRE(Block::index({-10, -7, -3}) == Block::index({6, 9, 13}));
REQUIRE(Block::index({-16, 0, 0}) == Block::index({0, 0, 0}));
REQUIRE(Block::index({-17, -18, -19}) == Block::index({15, 14, 13}));
}
// SECTION("Index") {
// REQUIRE(Space::Block::index({0, 0, 0}) == 0);
// REQUIRE(Space::Block::index({0, 5, 0}) == 80);
// REQUIRE(Space::Block::index({5, 20, 0}) == 69);
// REQUIRE(Space::Block::index({40, 20, 30}) == 3656);
// REQUIRE(Space::Block::index({0, -5, 0}) == 176);
// REQUIRE(Space::Block::index({-10, -7, -3}) == 3478);
// REQUIRE(Space::Block::index({-16, 0, 0}) == 0);
// REQUIRE(Space::Block::index({3, 3, 3}) == 819);
//
// REQUIRE(Space::Block::index({0, 0, 0}) == Space::Block::index({0, 0, 0}));
// REQUIRE(Space::Block::index({0, 17, 0}) == Space::Block::index({0, 1, 0}));
// REQUIRE(Space::Block::index({18, 32, 0}) == Space::Block::index({2, 0, 0}));
// REQUIRE(Space::Block::index({40, 20, 30}) == Space::Block::index({8, 4, 14}));
// REQUIRE(Space::Block::index({0, -5, 0}) == Space::Block::index({0, 11, 0}));
// REQUIRE(Space::Block::index({-10, -7, -3}) == Space::Block::index({6, 9, 13}));
// REQUIRE(Space::Block::index({-16, 0, 0}) == Space::Block::index({0, 0, 0}));
// REQUIRE(Space::Block::index({-17, -18, -19}) == Space::Block::index({15, 14, 13}));
// }
}
}