Mirrorlandia_minetest/minetest
1
0
Fork 1
mirror of https://github.com/minetest/minetest.git synced 2024-12-24 15:12:23 +01:00
Code Issues Packages Projects Releases Wiki Activity

8x block meshes (#13133)

Browse Source 
Reduce the number of drawcalls by generating a mesh per 8 blocks (2x2x2). Only blocks with even coordinates (lowest bit set to 0) will get a mesh.

Note: This also removes the old 'loops' algorithm for building the draw list, because it produces visual artifacts and cannot be made compatible with the approach of having a mesh for every 8th block without hurting performance.

Co-authored-by: Jude Melton-Houghton <jwmhjwmh@gmail.com>
Co-authored-by: Lars <larsh@apache.org>
Co-authored-by: sfan5 <sfan5@live.de>
This commit is contained in:
x2048 2023-01-31 17:30:59 +01:00 committed by GitHub
parent cded6a3945
commit 69fc206109
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 266 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
src/client/client.cpp
View File

@ -41,6 +41,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "filesys.h"
#include "mapblock_mesh.h"
#include "mapblock.h"
#include "mapsector.h"
#include "minimap.h"
#include "modchannels.h"
#include "content/mods.h"
@ -555,19 +556,27 @@ void Client::step(float dtime)
{
num_processed_meshes++;
MinimapMapblock *minimap_mapblock = NULL;
std::vector<MinimapMapblock*> minimap_mapblocks;
bool do_mapper_update = true;
MapBlock *block = m_env.getMap().getBlockNoCreateNoEx(r.p);
MapSector *sector = m_env.getMap().emergeSector(v2s16(r.p.X, r.p.Z));
MapBlock *block = sector->getBlockNoCreateNoEx(r.p.Y);
// The block in question is not visible (perhaps it is culled at the server),
// create a blank block just to hold the 2x2x2 mesh.
// If the block becomes visible later it will replace the blank block.
if (!block && r.mesh)
block = sector->createBlankBlock(r.p.Y);
if (block) {
// Delete the old mesh
delete block->mesh;
block->mesh = nullptr;
if (r.mesh) {
block->solid_sides = r.solid_sides;
minimap_mapblock = r.mesh->moveMinimapMapblock();
if (minimap_mapblock == NULL)
minimap_mapblocks = r.mesh->moveMinimapMapblocks();
if (minimap_mapblocks.empty())
do_mapper_update = false;
bool is_empty = true;
@ -588,16 +597,32 @@ void Client::step(float dtime)
delete r.mesh;
}
if (m_minimap && do_mapper_update)
m_minimap->addBlock(r.p, minimap_mapblock);
for (auto p : r.solid_sides) {
auto block = m_env.getMap().getBlockNoCreateNoEx(p.first);
if (block)
block->solid_sides = p.second;
}
if (r.ack_block_to_server) {
if (m_minimap && do_mapper_update) {
v3s16 ofs;
// See also mapblock_mesh.cpp for the code that creates the array of minimap blocks.
for (ofs.Z = 0; ofs.Z <= 1; ofs.Z++)
for (ofs.Y = 0; ofs.Y <= 1; ofs.Y++)
for (ofs.X = 0; ofs.X <= 1; ofs.X++) {
size_t i = ofs.Z * 4 + ofs.Y * 2 + ofs.X;
if (i < minimap_mapblocks.size() && minimap_mapblocks[i])
m_minimap->addBlock(r.p + ofs, minimap_mapblocks[i]);
}
}
for (auto p : r.ack_list) {
if (blocks_to_ack.size() == 255) {
sendGotBlocks(blocks_to_ack);
blocks_to_ack.clear();
}
blocks_to_ack.emplace_back(r.p);
blocks_to_ack.emplace_back(p);
}
for (auto block : r.map_blocks)

37
src/client/clientmap.cpp
View File

@ -298,6 +298,8 @@ void ClientMap::updateDrawList()
blocks_to_consider.push(camera_block);
blocks_seen.getChunk(camera_block).getBits(camera_block) = 0x07; // mark all sides as visible
std::set<v3s16> shortlist;
// Recursively walk the space and pick mapblocks for drawing
while (blocks_to_consider.size() > 0) {
@ -369,11 +371,13 @@ void ClientMap::updateDrawList()
continue;
}
// The block is visible, add to the draw list
if (mesh) {
// Add to set
// Block meshes are stored in blocks where all coordinates are even (lowest bit set to 0)
// Add them to the de-dup set.
shortlist.emplace(block_coord.X & ~1, block_coord.Y & ~1, block_coord.Z & ~1);
// All other blocks we can grab and add to the drawlist right away.
if (block && m_drawlist.emplace(block_coord, block).second) {
// only grab the ref if the block exists and was not in the list
block->refGrab();
m_drawlist[block_coord] = block;
}
// Decide which sides to traverse next or to block away
@ -474,6 +478,16 @@ void ClientMap::updateDrawList()
}
}
g_profiler->avg("MapBlocks shortlist [#]", shortlist.size());
for (auto pos : shortlist) {
MapBlock * block = getBlockNoCreateNoEx(pos);
if (block && m_drawlist.emplace(pos, block).second) {
// only grab the ref if the block exists and was not in the list
block->refGrab();
}
}
g_profiler->avg("MapBlocks occlusion culled [#]", blocks_occlusion_culled);
g_profiler->avg("MapBlocks sides skipped [#]", sides_skipped);
g_profiler->avg("MapBlocks examined [#]", blocks_visited);
@ -597,7 +611,11 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
MapBlock *block = i.second;
MapBlockMesh *block_mesh = block->mesh;
// If the mesh of the block happened to get deleted, ignore it
// Meshes are only stored every 8-th block (where all coordinates are even),
// but we keep all the visible blocks in the draw list to prevent client
// from dropping them.
// On top of that, in some cases block mesh can be removed
// before the block is removed from the draw list.
if (!block_mesh)
continue;
@ -720,7 +738,7 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
material.TextureLayer[ShadowRenderer::TEXTURE_LAYER_SHADOW].Texture = nullptr;
}
v3f block_wpos = intToFloat(descriptor.m_pos * MAP_BLOCKSIZE, BS);
v3f block_wpos = intToFloat(descriptor.m_pos / 8 * 8 * MAP_BLOCKSIZE, BS);
m.setTranslation(block_wpos - offset);
driver->setTransform(video::ETS_WORLD, m);
@ -1046,7 +1064,7 @@ void ClientMap::renderMapShadows(video::IVideoDriver *driver,
++material_swaps;
}
v3f block_wpos = intToFloat(descriptor.m_pos * MAP_BLOCKSIZE, BS);
v3f block_wpos = intToFloat(descriptor.m_pos / 8 * 8 * MAP_BLOCKSIZE, BS);
m.setTranslation(block_wpos - offset);
driver->setTransform(video::ETS_WORLD, m);
@ -1133,6 +1151,11 @@ void ClientMap::updateDrawListShadow(v3f shadow_light_pos, v3f shadow_light_dir,
g_profiler->avg("SHADOW MapBlocks loaded [#]", blocks_loaded);
}
void ClientMap::reportMetrics(u64 save_time_us, u32 saved_blocks, u32 all_blocks)
{
g_profiler->avg("CM::reportMetrics loaded blocks [#]", all_blocks);
}
void ClientMap::updateTransparentMeshBuffers()
{
ScopeProfiler sp(g_profiler, "CM::updateTransparentMeshBuffers", SPT_AVG);

2
src/client/clientmap.h
View File

@ -140,6 +140,8 @@ public:
void onSettingChanged(const std::string &name);
protected:
void reportMetrics(u64 save_time_us, u32 saved_blocks, u32 all_blocks) override;
private:
// update the vertex order in transparent mesh buffers

6
src/client/content_mapblock.cpp
View File

@ -1619,9 +1619,9 @@ void MapblockMeshGenerator::drawNode()
*/
void MapblockMeshGenerator::generate()
{
for (p.Z = 0; p.Z < MAP_BLOCKSIZE; p.Z++)
for (p.Y = 0; p.Y < MAP_BLOCKSIZE; p.Y++)
for (p.X = 0; p.X < MAP_BLOCKSIZE; p.X++) {
for (p.Z = 0; p.Z < data->side_length; p.Z++)
for (p.Y = 0; p.Y < data->side_length; p.Y++)
for (p.X = 0; p.X < data->side_length; p.X++) {
n = data->m_vmanip.getNodeNoEx(blockpos_nodes + p);
f = &nodedef->get(n);
drawNode();

84
src/client/mapblock_mesh.cpp
View File

@ -49,7 +49,7 @@ void MeshMakeData::fillBlockDataBegin(const v3s16 &blockpos)
m_vmanip.clear();
VoxelArea voxel_area(blockpos_nodes - v3s16(1,1,1) * MAP_BLOCKSIZE,
blockpos_nodes + v3s16(1,1,1) * MAP_BLOCKSIZE*2-v3s16(1,1,1));
blockpos_nodes + v3s16(1,1,1) * (side_length + MAP_BLOCKSIZE /* extra layer of blocks around the mesh */) - v3s16(1,1,1));
m_vmanip.addArea(voxel_area);
}
@ -63,23 +63,6 @@ void MeshMakeData::fillBlockData(const v3s16 &block_offset, MapNode *data)
m_vmanip.copyFrom(data, data_area, v3s16(0,0,0), blockpos_nodes, data_size);
}
void MeshMakeData::fill(MapBlock *block)
{
fillBlockDataBegin(block->getPos());
fillBlockData(v3s16(0,0,0), block->getData());
// Get map for reading neighbor blocks
Map *map = block->getParent();
for (const v3s16 &dir : g_26dirs) {
v3s16 bp = m_blockpos + dir;
MapBlock *b = map->getBlockNoCreateNoEx(bp);
if(b)
fillBlockData(dir, b->getData());
}
}
void MeshMakeData::setCrack(int crack_level, v3s16 crack_pos)
{
if (crack_level >= 0)
@ -883,7 +866,7 @@ static void updateFastFaceRow(
// Unroll this variable which has a significant build cost
TileSpec next_tile;
for (u16 j = 0; j < MAP_BLOCKSIZE; j++) {
for (u16 j = 0; j < data->side_length; j++) {
// If tiling can be done, this is set to false in the next step
bool next_is_different = true;
@ -894,7 +877,7 @@ static void updateFastFaceRow(
// If at last position, there is nothing to compare to and
// the face must be drawn anyway
if (j != MAP_BLOCKSIZE - 1) {
if (j != data->side_length - 1) {
p += translate_dir;
getTileInfo(data, p, face_dir,
@ -957,8 +940,8 @@ static void updateAllFastFaceRows(MeshMakeData *data,
/*
Go through every y,z and get top(y+) faces in rows of x+
*/
for (s16 y = 0; y < MAP_BLOCKSIZE; y++)
for (s16 z = 0; z < MAP_BLOCKSIZE; z++)
for (s16 y = 0; y < data->side_length; y++)
for (s16 z = 0; z < data->side_length; z++)
updateFastFaceRow(data,
v3s16(0, y, z),
v3s16(1, 0, 0), //dir
@ -969,8 +952,8 @@ static void updateAllFastFaceRows(MeshMakeData *data,
/*
Go through every x,y and get right(x+) faces in rows of z+
*/
for (s16 x = 0; x < MAP_BLOCKSIZE; x++)
for (s16 y = 0; y < MAP_BLOCKSIZE; y++)
for (s16 x = 0; x < data->side_length; x++)
for (s16 y = 0; y < data->side_length; y++)
updateFastFaceRow(data,
v3s16(x, y, 0),
v3s16(0, 0, 1), //dir
@ -981,8 +964,8 @@ static void updateAllFastFaceRows(MeshMakeData *data,
/*
Go through every y,z and get back(z+) faces in rows of x+
*/
for (s16 z = 0; z < MAP_BLOCKSIZE; z++)
for (s16 y = 0; y < MAP_BLOCKSIZE; y++)
for (s16 z = 0; z < data->side_length; z++)
for (s16 y = 0; y < data->side_length; y++)
updateFastFaceRow(data,
v3s16(0, y, z),
v3s16(1, 0, 0), //dir
@ -1009,7 +992,7 @@ static void applyTileColor(PreMeshBuffer &pmb)
MapBlockBspTree
*/
void MapBlockBspTree::buildTree(const std::vector<MeshTriangle> *triangles)
void MapBlockBspTree::buildTree(const std::vector<MeshTriangle> *triangles, u16 side_length)
{
this->triangles = triangles;
@ -1024,7 +1007,7 @@ void MapBlockBspTree::buildTree(const std::vector<MeshTriangle> *triangles)
if (!indexes.empty()) {
// Start in the center of the block with increment of one quarter in each direction
root = buildTree(v3f(1, 0, 0), v3f((MAP_BLOCKSIZE + 1) * 0.5f * BS), MAP_BLOCKSIZE * 0.25f * BS, indexes, 0);
root = buildTree(v3f(1, 0, 0), v3f((side_length + 1) * 0.5f * BS), side_length * 0.25f * BS, indexes, 0);
} else {
root = -1;
}
@ -1183,7 +1166,6 @@ void PartialMeshBuffer::afterDraw() const
*/
MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset):
m_minimap_mapblock(NULL),
m_tsrc(data->m_client->getTextureSource()),
m_shdrsrc(data->m_client->getShaderSource()),
m_animation_force_timer(0), // force initial animation
@ -1195,10 +1177,23 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset):
m_enable_shaders = data->m_use_shaders;
m_enable_vbo = g_settings->getBool("enable_vbo");
if (data->m_client->getMinimap()) {
m_minimap_mapblock = new MinimapMapblock;
m_minimap_mapblock->getMinimapNodes(
&data->m_vmanip, data->m_blockpos * MAP_BLOCKSIZE);
v3s16 bp = data->m_blockpos;
// Only generate minimap mapblocks at even coordinates.
if (((bp.X | bp.Y | bp.Z) & 1) == 0 && data->m_client->getMinimap()) {
m_minimap_mapblocks.resize(8, nullptr);
v3s16 ofs;
// See also client.cpp for the code that reads the array of minimap blocks.
for (ofs.Z = 0; ofs.Z <= 1; ofs.Z++)
for (ofs.Y = 0; ofs.Y <= 1; ofs.Y++)
for (ofs.X = 0; ofs.X <= 1; ofs.X++) {
v3s16 p = (bp + ofs) * MAP_BLOCKSIZE;
if (data->m_vmanip.getNodeNoEx(p).getContent() != CONTENT_IGNORE) {
MinimapMapblock *block = new MinimapMapblock;
m_minimap_mapblocks[ofs.Z * 4 + ofs.Y * 2 + ofs.X] = block;
block->getMinimapNodes(&data->m_vmanip, p);
}
}
}
// 4-21ms for MAP_BLOCKSIZE=16 (NOTE: probably outdated)
@ -1226,7 +1221,8 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset):
Convert FastFaces to MeshCollector
*/
MeshCollector collector(m_bounding_sphere_center);
v3f offset = intToFloat((data->m_blockpos - data->m_blockpos / 8 * 8) * MAP_BLOCKSIZE, BS);
MeshCollector collector(m_bounding_sphere_center, offset);
{
// avg 0ms (100ms spikes when loading textures the first time)
@ -1386,7 +1382,7 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset):
}
//std::cout<<"added "<<fastfaces.getSize()<<" faces."<<std::endl;
m_bsp_tree.buildTree(&m_transparent_triangles);
m_bsp_tree.buildTree(&m_transparent_triangles, data->side_length);
// Check if animation is required for this mesh
m_has_animation =
@ -1408,7 +1404,8 @@ MapBlockMesh::~MapBlockMesh()
#endif
m->drop();
}
delete m_minimap_mapblock;
for (MinimapMapblock *block : m_minimap_mapblocks)
delete block;
}
bool MapBlockMesh::animate(bool faraway, float time, int crack,
@ -1583,9 +1580,16 @@ video::SColor encode_light(u16 light, u8 emissive_light)
return video::SColor(r, b, b, b);
}
u8 get_solid_sides(MeshMakeData *data)
std::unordered_map<v3s16, u8> get_solid_sides(MeshMakeData *data)
{
v3s16 blockpos_nodes = data->m_blockpos * MAP_BLOCKSIZE;
std::unordered_map<v3s16, u8> results;
v3s16 ofs;
for (ofs.X = 0; ofs.X < 2; ofs.X++)
for (ofs.Y = 0; ofs.Y < 2; ofs.Y++)
for (ofs.Z = 0; ofs.Z < 2; ofs.Z++) {
v3s16 blockpos = data->m_blockpos + ofs;
v3s16 blockpos_nodes = blockpos * MAP_BLOCKSIZE;
const NodeDefManager *ndef = data->m_client->ndef();
u8 result = 0x3F; // all sides solid;
@ -1608,5 +1612,7 @@ u8 get_solid_sides(MeshMakeData *data)
}
}
return result;
results[blockpos] = result;
}
return results;
}

22
src/client/mapblock_mesh.h
View File

@ -24,6 +24,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "voxel.h"
#include <array>
#include <map>
#include <unordered_map>
class Client;
class IShaderSource;
@ -42,6 +43,7 @@ struct MeshMakeData
v3s16 m_blockpos = v3s16(-1337,-1337,-1337);
v3s16 m_crack_pos_relative = v3s16(-1337,-1337,-1337);
bool m_smooth_lighting = false;
u16 side_length = MAP_BLOCKSIZE;
Client *m_client;
bool m_use_shaders;
@ -54,12 +56,6 @@ struct MeshMakeData
void fillBlockDataBegin(const v3s16 &blockpos);
void fillBlockData(const v3s16 &block_offset, MapNode *data);
/*
Copy central data directly from block, and other data from
parent of block.
*/
void fill(MapBlock *block);
/*
Set the (node) position of a crack
*/
@ -108,7 +104,7 @@ class MapBlockBspTree
public:
MapBlockBspTree() {}
void buildTree(const std::vector<MeshTriangle> *triangles);
void buildTree(const std::vector<MeshTriangle> *triangles, u16 side_lingth);
void traverse(v3f viewpoint, std::vector<s32> &output) const
{
@ -203,11 +199,11 @@ public:
return m_mesh[layer];
}
MinimapMapblock *moveMinimapMapblock()
std::vector<MinimapMapblock*> moveMinimapMapblocks()
{
MinimapMapblock *p = m_minimap_mapblock;
m_minimap_mapblock = NULL;
return p;
std::vector<MinimapMapblock*> minimap_mapblocks;
minimap_mapblocks.swap(m_minimap_mapblocks);
return minimap_mapblocks;
}
bool isAnimationForced() const
@ -245,7 +241,7 @@ private:
};
scene::IMesh *m_mesh[MAX_TILE_LAYERS];
MinimapMapblock *m_minimap_mapblock;
std::vector<MinimapMapblock*> m_minimap_mapblocks;
ITextureSource *m_tsrc;
IShaderSource *m_shdrsrc;
@ -344,4 +340,4 @@ void getNodeTile(MapNode mn, const v3s16 &p, const v3s16 &dir, MeshMakeData *dat
/// Return bitset of the sides of the mapblock that consist of solid nodes only
/// Bits:
/// 0 0 -Z +Z -X +X -Y +Y
u8 get_solid_sides(MeshMakeData *data);
std::unordered_map<v3s16, u8> get_solid_sides(MeshMakeData *data);

56
src/client/mesh_generator_thread.cpp
View File

@ -25,6 +25,17 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "map.h"
#include "util/directiontables.h"
static class BlockPlaceholder {
public:
MapNode data[MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE];
BlockPlaceholder()
{
for (std::size_t i = 0; i < MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE; i++)
data[i] = MapNode(CONTENT_IGNORE);
}
} block_placeholder;
/*
QueuedMeshUpdate
*/
@ -66,28 +77,31 @@ bool MeshUpdateQueue::addBlock(Map *map, v3s16 p, bool ack_block_to_server, bool
MutexAutoLock lock(m_mutex);
// Mesh is placed at even positions at all coordinates
// (every 8-th block) and will cover 8 blocks
v3s16 mesh_position(p.X & ~1, p.Y & ~1, p.Z & ~1);
/*
Mark the block as urgent if requested
*/
if (urgent)
m_urgents.insert(p);
m_urgents.insert(mesh_position);
/*
Find if block is already in queue.
If it is, update the data and quit.
*/
for (QueuedMeshUpdate *q : m_queue) {
if (q->p == p) {
if (q->p == mesh_position) {
// NOTE: We are not adding a new position to the queue, thus
// refcount_from_queue stays the same.
if(ack_block_to_server)
q->ack_block_to_server = true;
q->ack_list.push_back(p);
q->crack_level = m_client->getCrackLevel();
q->crack_pos = m_client->getCrackPos();
q->urgent |= urgent;
for (std::size_t i = 1; i < q->map_blocks.size(); i++) {
for (std::size_t i = 0; i < q->map_blocks.size(); i++) {
if (!q->map_blocks[i]) {
MapBlock *block = map->getBlockNoCreateNoEx(q->p + g_26dirs[i - 1]);
MapBlock *block = map->getBlockNoCreateNoEx(q->p + g_64dirs[i]);
if (block) {
block->refGrab();
q->map_blocks[i] = block;
@ -99,16 +113,13 @@ bool MeshUpdateQueue::addBlock(Map *map, v3s16 p, bool ack_block_to_server, bool
}
/*
Cache the block data (force-update the center block, don't update the
neighbors but get them if they aren't already cached)
Make a list of blocks necessary for mesh generation and lock the blocks in memory.
*/
std::vector<MapBlock *> cached_blocks;
cached_blocks.reserve(3*3*3);
cached_blocks.push_back(main_block);
main_block->refGrab();
for (v3s16 dp : g_26dirs) {
MapBlock *block = map->getBlockNoCreateNoEx(p + dp);
cached_blocks.push_back(block);
std::vector<MapBlock *> map_blocks;
map_blocks.reserve(4*4*4);
for (v3s16 dp : g_64dirs) {
MapBlock *block = map->getBlockNoCreateNoEx(mesh_position + dp);
map_blocks.push_back(block);
if (block)
block->refGrab();
}
@ -117,12 +128,13 @@ bool MeshUpdateQueue::addBlock(Map *map, v3s16 p, bool ack_block_to_server, bool
Add the block
*/
QueuedMeshUpdate *q = new QueuedMeshUpdate;
q->p = p;
q->ack_block_to_server = ack_block_to_server;
q->p = mesh_position;
if(ack_block_to_server)
q->ack_list.push_back(p);
q->crack_level = m_client->getCrackLevel();
q->crack_pos = m_client->getCrackPos();
q->urgent = urgent;
q->map_blocks = std::move(cached_blocks);
q->map_blocks = std::move(map_blocks);
m_queue.push_back(q);
return true;
@ -170,12 +182,14 @@ void MeshUpdateQueue::fillDataFromMapBlocks(QueuedMeshUpdate *q)
{
MeshMakeData *data = new MeshMakeData(m_client, m_cache_enable_shaders);
q->data = data;
data->side_length = 2 * MAP_BLOCKSIZE;
data->fillBlockDataBegin(q->p);
for (MapBlock *block : q->map_blocks)
if (block)
data->fillBlockData(block->getPos() - q->p, block->getData());
for (std::size_t i = 0; i < 64; i++) {
MapBlock *block = q->map_blocks[i];
data->fillBlockData(g_64dirs[i], block ? block->getData() : block_placeholder.data);
}
data->setCrack(q->crack_level, q->crack_pos);
data->setSmoothLighting(m_cache_smooth_lighting);
@ -208,7 +222,7 @@ void MeshUpdateWorkerThread::doUpdate()
r.p = q->p;
r.mesh = mesh_new;
r.solid_sides = get_solid_sides(q->data);
r.ack_block_to_server = q->ack_block_to_server;
r.ack_list = std::move(q->ack_list);
r.urgent = q->urgent;
r.map_blocks = q->map_blocks;

7
src/client/mesh_generator_thread.h
View File

@ -28,11 +28,12 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "util/thread.h"
#include <vector>
#include <memory>
#include <unordered_map>
struct QueuedMeshUpdate
{
v3s16 p = v3s16(-1337, -1337, -1337);
bool ack_block_to_server = false;
std::vector<v3s16> ack_list;
int crack_level = -1;
v3s16 crack_pos;
MeshMakeData *data = nullptr; // This is generated in MeshUpdateQueue::pop()
@ -96,8 +97,8 @@ struct MeshUpdateResult
{
v3s16 p = v3s16(-1338, -1338, -1338);
MapBlockMesh *mesh = nullptr;
u8 solid_sides = 0;
bool ack_block_to_server = false;
std::unordered_map<v3s16, u8> solid_sides;
std::vector<v3s16> ack_list;
bool urgent = false;
std::vector<MapBlock *> map_blocks;

4
src/client/meshgen/collector.cpp
View File

@ -46,7 +46,7 @@ void MeshCollector::append(const TileLayer &layer, const video::S3DVertex *verti
u32 vertex_count = p.vertices.size();
for (u32 i = 0; i < numVertices; i++) {
p.vertices.emplace_back(vertices[i].Pos, vertices[i].Normal,
p.vertices.emplace_back(vertices[i].Pos + offset, vertices[i].Normal,
vertices[i].Color, scale * vertices[i].TCoords);
m_bounding_radius_sq = std::max(m_bounding_radius_sq,
(vertices[i].Pos - m_center_pos).getLengthSQ());
@ -84,7 +84,7 @@ void MeshCollector::append(const TileLayer &layer, const video::S3DVertex *verti
video::SColor color = c;
if (!light_source)
applyFacesShading(color, vertices[i].Normal);
auto vpos = vertices[i].Pos + pos;
auto vpos = vertices[i].Pos + pos + offset;
p.vertices.emplace_back(vpos, vertices[i].Normal, color,
scale * vertices[i].TCoords);
m_bounding_radius_sq = std::max(m_bounding_radius_sq,

5
src/client/meshgen/collector.h
View File

@ -21,6 +21,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <array>
#include <vector>
#include "irrlichttypes.h"
#include "irr_v3d.h"
#include <S3DVertex.h>
#include "client/tile.h"
@ -40,9 +41,11 @@ struct MeshCollector
// bounding sphere radius and center
f32 m_bounding_radius_sq = 0.0f;
v3f m_center_pos;
v3f offset;
// center_pos: pos to use for bounding-sphere, in BS-space
MeshCollector(const v3f center_pos) : m_center_pos(center_pos) {}
// offset: offset added to vertices
MeshCollector(const v3f center_pos, v3f offset = v3f()) : m_center_pos(center_pos), offset(offset) {}
// clang-format off
void append(const TileSpec &material,

2
src/client/wieldmesh.cpp
View File

@ -318,7 +318,7 @@ static scene::SMesh *createSpecialNodeMesh(Client *client, MapNode n,
std::vector<ItemPartColor> *colors, const ContentFeatures &f)
{
MeshMakeData mesh_make_data(client, false);
MeshCollector collector(v3f(0.0f * BS));
MeshCollector collector(v3f(0.0f * BS), v3f());
mesh_make_data.setSmoothLighting(false);
MapblockMeshGenerator gen(&mesh_make_data, &collector,
client->getSceneManager()->getMeshManipulator());

7
src/map.cpp
View File

@ -325,6 +325,7 @@ void Map::timerUpdate(float dtime, float unload_timeout, s32 max_loaded_blocks,
u32 deleted_blocks_count = 0;
u32 saved_blocks_count = 0;
u32 block_count_all = 0;
u32 locked_blocks = 0;
const auto start_time = porting::getTimeUs();
beginSave();
@ -396,8 +397,10 @@ void Map::timerUpdate(float dtime, float unload_timeout, s32 max_loaded_blocks,
MapBlock *block = b.block;
if (block->refGet() != 0)
if (block->refGet() != 0) {
locked_blocks++;
continue;
}
v3s16 p = block->getPos();
@ -442,7 +445,7 @@ void Map::timerUpdate(float dtime, float unload_timeout, s32 max_loaded_blocks,
<<" blocks from memory";
if(save_before_unloading)
infostream<<", of which "<<saved_blocks_count<<" were written";
infostream<<", "<<block_count_all<<" blocks in memory";
infostream<<", "<<block_count_all<<" blocks in memory, " << locked_blocks << " locked";
infostream<<"."<<std::endl;
if(saved_blocks_count != 0){
PrintInfo(infostream); // ServerMap/ClientMap:

72
src/util/directiontables.cpp
View File

@ -110,6 +110,78 @@ const v3s16 g_27dirs[27] =
v3s16(0,0,0),
};
const v3s16 g_64dirs[64] =
{
// +right, +top, +back
v3s16( -1, -1, -1),
v3s16( -1, 0, -1),
v3s16( -1, 1, -1),
v3s16( -1, 2, -1),
v3s16( -1, -1, 0),
v3s16( -1, 0, 0),
v3s16( -1, 1, 0),
v3s16( -1, 2, 0),
v3s16( -1, -1, 1),
v3s16( -1, 0, 1),
v3s16( -1, 1, 1),
v3s16( -1, 2, 1),
v3s16( -1, -1, 2),
v3s16( -1, 0, 2),
v3s16( -1, 1, 2),
v3s16( -1, 2, 2),
v3s16( 0, -1, -1),
v3s16( 0, 0, -1),
v3s16( 0, 1, -1),
v3s16( 0, 2, -1),
v3s16( 0, -1, 0),
v3s16( 0, 0, 0),
v3s16( 0, 1, 0),
v3s16( 0, 2, 0),
v3s16( 0, -1, 1),
v3s16( 0, 0, 1),
v3s16( 0, 1, 1),
v3s16( 0, 2, 1),
v3s16( 0, -1, 2),
v3s16( 0, 0, 2),
v3s16( 0, 1, 2),
v3s16( 0, 2, 2),
v3s16( 1, -1, -1),
v3s16( 1, 0, -1),
v3s16( 1, 1, -1),
v3s16( 1, 2, -1),
v3s16( 1, -1, 0),
v3s16( 1, 0, 0),
v3s16( 1, 1, 0),
v3s16( 1, 2, 0),
v3s16( 1, -1, 1),
v3s16( 1, 0, 1),
v3s16( 1, 1, 1),
v3s16( 1, 2, 1),
v3s16( 1, -1, 2),
v3s16( 1, 0, 2),
v3s16( 1, 1, 2),
v3s16( 1, 2, 2),
v3s16( 2, -1, -1),
v3s16( 2, 0, -1),
v3s16( 2, 1, -1),
v3s16( 2, 2, -1),
v3s16( 2, -1, 0),
v3s16( 2, 0, 0),
v3s16( 2, 1, 0),
v3s16( 2, 2, 0),
v3s16( 2, -1, 1),
v3s16( 2, 0, 1),
v3s16( 2, 1, 1),
v3s16( 2, 2, 1),
v3s16( 2, -1, 2),
v3s16( 2, 0, 2),
v3s16( 2, 1, 2),
v3s16( 2, 2, 2),
};
const u8 wallmounted_to_facedir[6] = {
20,
0,

3
src/util/directiontables.h
View File

@ -31,6 +31,9 @@ extern const v3s16 g_26dirs[26];
// 26th is (0,0,0)
extern const v3s16 g_27dirs[27];
// all positions around an octablock in sector-first order
extern const v3s16 g_64dirs[64];
extern const u8 wallmounted_to_facedir[6];
extern const v3s16 wallmounted_dirs[8];