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>
#include "filesys.h"
#include "mapblock_mesh.h"
#include "mapblock.h"
+#include "mapsector.h"
#include "minimap.h"
#include "modchannels.h"
#include "content/mods.h"
{
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;
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 (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]);
+ }
+ }
- if (r.ack_block_to_server) {
+ 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)
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) {
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
}
}
+ 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);
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;
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);
++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);
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);
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
*/
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();
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);
}
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)
// 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;
// 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,
/*
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
/*
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
/*
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
MapBlockBspTree
*/
-void MapBlockBspTree::buildTree(const std::vector<MeshTriangle> *triangles)
+void MapBlockBspTree::buildTree(const std::vector<MeshTriangle> *triangles, u16 side_length)
{
this->triangles = 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;
}
*/
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
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)
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)
}
//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 =
#endif
m->drop();
}
- delete m_minimap_mapblock;
+ for (MinimapMapblock *block : m_minimap_mapblocks)
+ delete block;
}
bool MapBlockMesh::animate(bool faraway, float time, int crack,
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;
- const NodeDefManager *ndef = data->m_client->ndef();
-
- u8 result = 0x3F; // all sides solid;
-
- for (s16 i = 0; i < MAP_BLOCKSIZE && result != 0; i++)
- for (s16 j = 0; j < MAP_BLOCKSIZE && result != 0; j++) {
- v3s16 positions[6] = {
- v3s16(0, i, j),
- v3s16(MAP_BLOCKSIZE - 1, i, j),
- v3s16(i, 0, j),
- v3s16(i, MAP_BLOCKSIZE - 1, j),
- v3s16(i, j, 0),
- v3s16(i, j, MAP_BLOCKSIZE - 1)
- };
-
- for (u8 k = 0; k < 6; k++) {
- const MapNode &top = data->m_vmanip.getNodeRefUnsafe(blockpos_nodes + positions[k]);
- if (ndef->get(top).solidness != 2)
- result &= ~(1 << k);
+ 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;
+
+ for (s16 i = 0; i < MAP_BLOCKSIZE && result != 0; i++)
+ for (s16 j = 0; j < MAP_BLOCKSIZE && result != 0; j++) {
+ v3s16 positions[6] = {
+ v3s16(0, i, j),
+ v3s16(MAP_BLOCKSIZE - 1, i, j),
+ v3s16(i, 0, j),
+ v3s16(i, MAP_BLOCKSIZE - 1, j),
+ v3s16(i, j, 0),
+ v3s16(i, j, MAP_BLOCKSIZE - 1)
+ };
+
+ for (u8 k = 0; k < 6; k++) {
+ const MapNode &top = data->m_vmanip.getNodeRefUnsafe(blockpos_nodes + positions[k]);
+ if (ndef->get(top).solidness != 2)
+ result &= ~(1 << k);
+ }
}
- }
- return result;
+ results[blockpos] = result;
+ }
+ return results;
}
#include "voxel.h"
#include <array>
#include <map>
+#include <unordered_map>
class Client;
class IShaderSource;
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;
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
*/
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
{
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
};
scene::IMesh *m_mesh[MAX_TILE_LAYERS];
- MinimapMapblock *m_minimap_mapblock;
+ std::vector<MinimapMapblock*> m_minimap_mapblocks;
ITextureSource *m_tsrc;
IShaderSource *m_shdrsrc;
/// 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);
#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
*/
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;
}
/*
- 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();
}
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;
{
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);
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;
#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()
{
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;
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());
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,
#include <array>
#include <vector>
#include "irrlichttypes.h"
+#include "irr_v3d.h"
#include <S3DVertex.h>
#include "client/tile.h"
// 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,
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());
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();
MapBlock *block = b.block;
- if (block->refGet() != 0)
+ if (block->refGet() != 0) {
+ locked_blocks++;
continue;
+ }
v3s16 p = block->getPos();
<<" 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:
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,
// 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];
projects / minetest.git / commitdiff