PulseStudio/VoxelEngine
PulseStudio/VoxelEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

add blocks_agent templates & remove block.get_slow

Browse Source
This commit is contained in:
MihailRis 2024-12-16 11:26:57 +03:00
parent 5bf56d1f64
commit 6157f8193d
9 changed files with 158 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
dev/tests/example.lua
View File

@ -8,11 +8,8 @@ assert(player.get_name(pid) == "Xerxes")
test.sleep_until(function() return world.count_chunks() >= 9 end, 1000)
print(world.count_chunks())
for i=1,3 do
print("---")
timeit(1000000, block.get, 0, 0, 0)
timeit(1000000, block.get_slow, 0, 0, 0)
end
timeit(10000000, block.get, 0, 0, 0)
timeit(10000000, core.blank, 0, 0, 0)
block.destruct(0, 0, 0, pid)
assert(block.get(0, 0, 0) == 0)

5
src/constants.hpp
View File

@ -35,6 +35,11 @@ inline constexpr int CHUNK_D = 16;
inline constexpr uint VOXEL_USER_BITS = 8;
inline constexpr uint VOXEL_USER_BITS_OFFSET = sizeof(blockstate_t)*8-VOXEL_USER_BITS;
/// @brief % unordered map max average buckets load factor.
/// Low value gives significant performance impact by minimizing collisions and
/// lookup latency. Default value (1.0) shows x2 slower work.
inline constexpr float CHUNKS_MAP_MAX_LOAD_FACTOR = 0.1f;
/// @brief chunk volume (count of voxels per Chunk)
inline constexpr int CHUNK_VOL = (CHUNK_W * CHUNK_H * CHUNK_D);

56
src/logic/scripting/lua/libs/libblock.cpp
View File

@ -8,6 +8,7 @@
#include "voxels/Chunks.hpp"
#include "voxels/voxel.hpp"
#include "voxels/GlobalChunks.hpp"
#include "voxels/blocks_agent.hpp"
#include "world/Level.hpp"
#include "maths/voxmaths.hpp"
#include "data/StructLayout.hpp"
@ -15,13 +16,13 @@
using namespace scripting;
static const Block* require_block(lua::State* L) {
static inline const Block* require_block(lua::State* L) {
auto indices = content->getIndices();
auto id = lua::tointeger(L, 1);
return indices->blocks.get(id);
}
static int l_get_def(lua::State* L) {
static inline int l_get_def(lua::State* L) {
if (auto def = require_block(L)) {
return lua::pushstring(L, def->name);
}
@ -39,8 +40,7 @@ static int l_is_solid_at(lua::State* L) {
auto x = lua::tointeger(L, 1);
auto y = lua::tointeger(L, 2);
auto z = lua::tointeger(L, 3);
return lua::pushboolean(L, level->chunks->isSolidBlock(x, y, z));
return lua::pushboolean(L, blocks_agent::is_solid_at(*level->chunks, x, y, z));
}
static int l_count(lua::State* L) {
@ -110,16 +110,7 @@ static int l_get(lua::State* L) {
auto x = lua::tointeger(L, 1);
auto y = lua::tointeger(L, 2);
auto z = lua::tointeger(L, 3);
auto vox = level->chunks->get(x, y, z);
int id = vox == nullptr ? -1 : vox->id;
return lua::pushinteger(L, id);
}
static int l_get_slow(lua::State* L) {
auto x = lua::tointeger(L, 1);
auto y = lua::tointeger(L, 2);
auto z = lua::tointeger(L, 3);
auto vox = level->chunksStorage->get(x, y, z);
auto vox = blocks_agent::get(*level->chunksStorage, x, y, z);
int id = vox == nullptr ? -1 : vox->id;
return lua::pushinteger(L, id);
}
@ -128,7 +119,7 @@ static int l_get_x(lua::State* L) {
auto x = lua::tointeger(L, 1);
auto y = lua::tointeger(L, 2);
auto z = lua::tointeger(L, 3);
auto vox = level->chunksStorage->get(x, y, z);
auto vox = blocks_agent::get(*level->chunksStorage, x, y, z);
if (vox == nullptr) {
return lua::pushivec_stack(L, glm::ivec3(1, 0, 0));
}
@ -145,7 +136,7 @@ static int l_get_y(lua::State* L) {
auto x = lua::tointeger(L, 1);
auto y = lua::tointeger(L, 2);
auto z = lua::tointeger(L, 3);
auto vox = level->chunksStorage->get(x, y, z);
auto vox = blocks_agent::get(*level->chunksStorage, x, y, z);
if (vox == nullptr) {
return lua::pushivec_stack(L, glm::ivec3(0, 1, 0));
}
@ -162,7 +153,7 @@ static int l_get_z(lua::State* L) {
auto x = lua::tointeger(L, 1);
auto y = lua::tointeger(L, 2);
auto z = lua::tointeger(L, 3);
auto vox = level->chunksStorage->get(x, y, z);
auto vox = blocks_agent::get(*level->chunksStorage, x, y, z);
if (vox == nullptr) {
return lua::pushivec_stack(L, glm::ivec3(0, 0, 1));
}
@ -179,7 +170,7 @@ static int l_get_rotation(lua::State* L) {
auto x = lua::tointeger(L, 1);
auto y = lua::tointeger(L, 2);
auto z = lua::tointeger(L, 3);
voxel* vox = level->chunksStorage->get(x, y, z);
auto vox = blocks_agent::get(*level->chunksStorage, x, y, z);
int rotation = vox == nullptr ? 0 : vox->state.rotation;
return lua::pushinteger(L, rotation);
}
@ -197,7 +188,7 @@ static int l_get_states(lua::State* L) {
auto x = lua::tointeger(L, 1);
auto y = lua::tointeger(L, 2);
auto z = lua::tointeger(L, 3);
auto vox = level->chunksStorage->get(x, y, z);
auto vox = blocks_agent::get(*level->chunksStorage, x, y, z);
int states = vox == nullptr ? 0 : blockstate2int(vox->state);
return lua::pushinteger(L, states);
}
@ -226,7 +217,7 @@ static int l_get_user_bits(lua::State* L) {
auto offset = lua::tointeger(L, 4) + VOXEL_USER_BITS_OFFSET;
auto bits = lua::tointeger(L, 5);
auto vox = level->chunks->get(x, y, z);
auto vox = blocks_agent::get(*level->chunksStorage, x, y, z);
if (vox == nullptr) {
return lua::pushinteger(L, 0);
}
@ -352,7 +343,7 @@ static int l_place(lua::State* L) {
if (static_cast<size_t>(id) >= indices->blocks.count()) {
return 0;
}
if (!level->chunks->get(x, y, z)) {
if (!blocks_agent::get(*level->chunksStorage, x, y, z)) {
return 0;
}
const auto def = level->content->getIndices()->blocks.get(id);
@ -373,11 +364,11 @@ static int l_destruct(lua::State* L) {
auto y = lua::tointeger(L, 2);
auto z = lua::tointeger(L, 3);
auto playerid = lua::gettop(L) >= 4 ? lua::tointeger(L, 4) : -1;
auto voxel = level->chunks->get(x, y, z);
if (voxel == nullptr) {
auto vox = blocks_agent::get(*level->chunksStorage, x, y, z);
if (vox == nullptr) {
return 0;
}
auto& def = level->content->getIndices()->blocks.require(voxel->id);
auto& def = level->content->getIndices()->blocks.require(vox->id);
auto player = level->players->get(playerid);
controller->getBlocksController()->breakBlock(player, def, x, y, z);
return 0;
@ -504,12 +495,15 @@ static int l_get_field(lua::State* L) {
}
auto cx = floordiv(x, CHUNK_W);
auto cz = floordiv(z, CHUNK_D);
auto chunk = level->chunks->getChunk(cx, cz);
auto chunk = blocks_agent::get_chunk(*level->chunksStorage, cx, cz);
if (chunk == nullptr || y < 0 || y >= CHUNK_H) {
return 0;
}
auto lx = x - cx * CHUNK_W;
auto lz = z - cz * CHUNK_W;
size_t voxelIndex = vox_index(lx, y, lz);
const auto& vox = level->chunks->require(x, y, z);
const auto& vox = chunk->voxels[voxelIndex];
const auto& def = content->getIndices()->blocks.require(vox.id);
if (def.dataStruct == nullptr) {
return 0;
@ -568,15 +562,18 @@ static int l_set_field(lua::State* L) {
if (lua::gettop(L) >= 6) {
index = lua::tointeger(L, 6);
}
auto vox = level->chunks->get(x, y, z);
auto cx = floordiv(x, CHUNK_W);
auto cz = floordiv(z, CHUNK_D);
auto chunk = level->chunks->getChunk(cx, cz);
auto lx = x - cx * CHUNK_W;
auto lz = z - cz * CHUNK_W;
auto chunk = blocks_agent::get_chunk(*level->chunksStorage, cx, cz);
if (chunk == nullptr || y < 0 || y >= CHUNK_H) {
return 0;
}
size_t voxelIndex = vox_index(lx, y, lz);
const auto& vox = chunk->voxels[voxelIndex];
const auto& def = content->getIndices()->blocks.require(vox->id);
const auto& def = content->getIndices()->blocks.require(vox.id);
if (def.dataStruct == nullptr) {
return 0;
}
@ -608,7 +605,6 @@ const luaL_Reg blocklib[] = {
{"is_replaceable_at", lua::wrap<l_is_replaceable_at>},
{"set", lua::wrap<l_set>},
{"get", lua::wrap<l_get>},
{"get_slow", lua::wrap<l_get_slow>},
{"get_X", lua::wrap<l_get_x>},
{"get_Y", lua::wrap<l_get_y>},
{"get_Z", lua::wrap<l_get_z>},

5
src/logic/scripting/lua/libs/libcore.cpp
View File

@ -16,6 +16,7 @@
#include "logic/EngineController.hpp"
#include "logic/LevelController.hpp"
#include "util/listutil.hpp"
#include "util/platform.hpp"
#include "window/Events.hpp"
#include "window/Window.hpp"
#include "world/Level.hpp"
@ -220,8 +221,6 @@ static int l_load_texture(lua::State* L) {
return 0;
}
#include "util/platform.hpp"
static int l_open_folder(lua::State* L) {
auto path = engine->getPaths()->resolve(lua::require_string(L, 1));
platform::open_folder(path);
@ -239,7 +238,7 @@ static int l_blank(lua::State*) {
}
const luaL_Reg corelib[] = {
{"nop", lua::wrap<l_blank>},
{"blank", lua::wrap<l_blank>},
{"get_version", lua::wrap<l_get_version>},
{"new_world", lua::wrap<l_new_world>},
{"open_world", lua::wrap<l_open_world>},

30
src/voxels/Chunks.cpp
View File

@ -23,6 +23,7 @@
#include "Block.hpp"
#include "Chunk.hpp"
#include "voxel.hpp"
#include "blocks_agent.hpp"
Chunks::Chunks(
int32_t w,
@ -33,7 +34,7 @@ Chunks::Chunks(
Level* level
)
: level(level),
indices(level->content->getIndices()),
indices(level ? level->content->getIndices() : nullptr),
areaMap(w, d),
worldFiles(wfile) {
areaMap.setCenter(ox-w/2, oz-d/2);
@ -43,30 +44,11 @@ Chunks::Chunks(
}
voxel* Chunks::get(int32_t x, int32_t y, int32_t z) const {
if (y < 0 || y >= CHUNK_H) {
return nullptr;
}
int cx = floordiv<CHUNK_W>(x);
int cz = floordiv<CHUNK_D>(z);
auto ptr = areaMap.getIf(cx, cz);
if (ptr == nullptr) {
return nullptr;
}
Chunk* chunk = ptr->get();
if (chunk == nullptr) {
return nullptr;
}
int lx = x - cx * CHUNK_W;
int lz = z - cz * CHUNK_D;
return &chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx];
return blocks_agent::get(*this, x, y, z);
}
voxel& Chunks::require(int32_t x, int32_t y, int32_t z) const {
auto voxel = get(x, y, z);
if (voxel == nullptr) {
throw std::runtime_error("voxel does not exist");
}
return *voxel;
return blocks_agent::require(*this, x, y, z);
}
const AABB* Chunks::isObstacleAt(float x, float y, float z) const {
@ -103,9 +85,7 @@ const AABB* Chunks::isObstacleAt(float x, float y, float z) const {
}
bool Chunks::isSolidBlock(int32_t x, int32_t y, int32_t z) {
voxel* v = get(x, y, z);
if (v == nullptr) return false;
return indices->blocks.require(v->id).rt.solid;
return blocks_agent::is_solid_at(*this, x, y, z);
}
bool Chunks::isReplaceableBlock(int32_t x, int32_t y, int32_t z) {

4
src/voxels/Chunks.hpp
View File

@ -152,4 +152,8 @@ public:
size_t getVolume() const {
return areaMap.area();
}
const ContentIndices& getContentIndices() const {
return *indices;
}
};

83
src/voxels/GlobalChunks.cpp
View File

@ -16,10 +16,10 @@
#include "Block.hpp"
#include "Chunk.hpp"
inline long long keyfrom(int x, int z) {
inline uint64_t keyfrom(int32_t x, int32_t z) {
union {
int pos[2];
long long key;
int32_t pos[2];
uint64_t key;
} ekey;
ekey.pos[0] = x;
ekey.pos[1] = z;
@ -28,7 +28,9 @@ inline long long keyfrom(int x, int z) {
static debug::Logger logger("chunks-storage");
GlobalChunks::GlobalChunks(Level* level) : level(level) {
GlobalChunks::GlobalChunks(Level* level)
: level(level), indices(level ? level->content->getIndices() : nullptr) {
chunksMap.max_load_factor(CHUNKS_MAP_MAX_LOAD_FACTOR);
}
std::shared_ptr<Chunk> GlobalChunks::fetch(int x, int z) {
@ -67,6 +69,29 @@ void GlobalChunks::erase(int x, int z) {
chunksMap.erase(keyfrom(x, z));
}
static inline auto load_inventories(
WorldRegions& regions,
const Chunk& chunk,
const ContentUnitIndices<Block>& defs
) {
auto invs = regions.fetchInventories(chunk.x, chunk.z);
auto iterator = invs.begin();
while (iterator != invs.end()) {
uint index = iterator->first;
const auto& def = defs.require(chunk.voxels[index].id);
if (def.inventorySize == 0) {
iterator = invs.erase(iterator);
continue;
}
auto& inventory = iterator->second;
if (def.inventorySize != inventory->size()) {
inventory->resize(def.inventorySize);
}
++iterator;
}
return invs;
}
std::shared_ptr<Chunk> GlobalChunks::create(int x, int z) {
const auto& found = chunksMap.find(keyfrom(x, z));
if (found != chunksMap.end()) {
@ -84,22 +109,10 @@ std::shared_ptr<Chunk> GlobalChunks::create(int x, int z) {
chunk->decode(data.get());
check_voxels(indices, *chunk);
auto invs = regions.fetchInventories(chunk->x, chunk->z);
auto iterator = invs.begin();
while (iterator != invs.end()) {
uint index = iterator->first;
const auto& def = indices.blocks.require(chunk->voxels[index].id);
if (def.inventorySize == 0) {
iterator = invs.erase(iterator);
continue;
}
auto& inventory = iterator->second;
if (def.inventorySize != inventory->size()) {
inventory->resize(def.inventorySize);
}
++iterator;
}
chunk->setBlockInventories(std::move(invs));
chunk->setBlockInventories(
load_inventories(regions, *chunk, indices.blocks)
);
auto entitiesData = regions.fetchEntities(chunk->x, chunk->z);
if (entitiesData.getType() == dv::value_type::object) {
@ -132,24 +145,6 @@ size_t GlobalChunks::size() const {
return chunksMap.size();
}
voxel* GlobalChunks::get(int x, int y, int z) const {
if (y < 0 || y >= CHUNK_H) {
return nullptr;
}
int cx = floordiv<CHUNK_W>(x);
int cz = floordiv<CHUNK_D>(z);
const auto& found = chunksMap.find(keyfrom(cx, cz));
if (found == chunksMap.end()) {
return nullptr;
}
const auto& chunk = found->second;
int lx = x - cx * CHUNK_W;
int lz = z - cz * CHUNK_D;
return &chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx];
}
void GlobalChunks::incref(Chunk* chunk) {
auto key = reinterpret_cast<ptrdiff_t>(chunk);
const auto& found = refCounters.find(key);
@ -209,3 +204,15 @@ void GlobalChunks::saveAll() {
save(chunk.get());
}
}
void GlobalChunks::putChunk(std::shared_ptr<Chunk> chunk) {
chunksMap[keyfrom(chunk->x, chunk->z)] = std::move(chunk);
}
Chunk* GlobalChunks::getChunk(int cx, int cz) const {
const auto& found = chunksMap.find(keyfrom(cx, cz));
if (found == chunksMap.end()) {
return nullptr;
}
return found->second.get();
}

14
src/voxels/GlobalChunks.hpp
View File

@ -11,10 +11,12 @@
class Chunk;
class Level;
class ContentIndices;
class GlobalChunks {
Level* level;
std::unordered_map<long long, std::shared_ptr<Chunk>> chunksMap;
const ContentIndices* indices;
std::unordered_map<uint64_t, std::shared_ptr<Chunk>> chunksMap;
std::unordered_map<glm::ivec2, std::shared_ptr<Chunk>> pinnedChunks;
std::unordered_map<ptrdiff_t, int> refCounters;
public:
@ -27,8 +29,6 @@ public:
void pinChunk(std::shared_ptr<Chunk> chunk);
void unpinChunk(int x, int z);
voxel* get(int x, int y, int z) const;
size_t size() const;
void incref(Chunk* chunk);
@ -38,4 +38,12 @@ public:
void save(Chunk* chunk);
void saveAll();
void putChunk(std::shared_ptr<Chunk> chunk);
Chunk* getChunk(int cx, int cz) const;
const ContentIndices& getContentIndices() const {
return *indices;
}
};

58
src/voxels/blocks_agent.hpp Normal file
View File

@ -0,0 +1,58 @@
#pragma once
#include "voxel.hpp"
#include "typedefs.hpp"
#include "maths/voxmaths.hpp"
class Chunk;
class Chunks;
class GlobalChunks;
/// Using templates to minimize OOP overhead
namespace blocks_agent {
template<class Storage>
inline Chunk* get_chunk(const Storage& chunks, int cx, int cz) {
return chunks.getChunk(cx, cz);
}
template<class Storage>
inline voxel* get(const Storage& chunks, int32_t x, int32_t y, int32_t z) {
if (y < 0 || y >= CHUNK_H) {
return nullptr;
}
int cx = floordiv<CHUNK_W>(x);
int cz = floordiv<CHUNK_D>(z);
Chunk* chunk = get_chunk(chunks, cx, cz);
if (chunk == nullptr) {
return nullptr;
}
int lx = x - cx * CHUNK_W;
int lz = z - cz * CHUNK_D;
return &chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx];
}
template<class Storage>
inline voxel& require(const Storage& chunks, int32_t x, int32_t y, int32_t z) {
auto vox = get(chunks, x, y, z);
if (vox == nullptr) {
throw std::runtime_error("voxel does not exist");
}
return *vox;
}
template<class Storage>
inline const Block& get_block_def(const Storage& chunks, blockid_t id) {
return chunks.getContentIndices().blocks.require(id);
}
template<class Storage>
inline bool is_solid_at(const Storage& chunks, int32_t x, int32_t y, int32_t z) {
if (auto vox = get(chunks, x, y, z)) {
return get_block_def(chunks, vox->id).rt.solid;
}
return false;
}
} // blocks_agent