#include "client/meshgen/collector.h"
#include "client/renderingengine.h"
#include <array>
+#include <algorithm>
/*
MeshMakeData
*/
-MeshMakeData::MeshMakeData(Client *client, bool use_shaders,
- bool use_tangent_vertices):
+MeshMakeData::MeshMakeData(Client *client, bool use_shaders):
+ m_mesh_grid(client->getMeshGrid()),
+ side_length(MAP_BLOCKSIZE * m_mesh_grid.cell_size),
m_client(client),
- m_use_shaders(use_shaders),
- m_use_tangent_vertices(use_tangent_vertices)
+ m_use_shaders(use_shaders)
{}
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);
}
-void MeshMakeData::fillBlockData(const v3s16 &block_offset, MapNode *data)
+void MeshMakeData::fillBlockData(const v3s16 &bp, MapNode *data)
{
v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1));
- v3s16 bp = m_blockpos + block_offset;
v3s16 blockpos_nodes = bp * MAP_BLOCKSIZE;
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::fillSingleNode(MapNode *node)
-{
- m_blockpos = v3s16(0,0,0);
-
- v3s16 blockpos_nodes = v3s16(0,0,0);
- VoxelArea area(blockpos_nodes-v3s16(1,1,1)*MAP_BLOCKSIZE,
- blockpos_nodes+v3s16(1,1,1)*MAP_BLOCKSIZE*2-v3s16(1,1,1));
- s32 volume = area.getVolume();
- s32 our_node_index = area.index(1,1,1);
-
- // Allocate this block + neighbors
- m_vmanip.clear();
- m_vmanip.addArea(area);
-
- // Fill in data
- MapNode *data = new MapNode[volume];
- for(s32 i = 0; i < volume; i++)
- {
- if (i == our_node_index)
- data[i] = *node;
- else
- data[i] = MapNode(CONTENT_AIR, LIGHT_MAX, 0);
- }
- m_vmanip.copyFrom(data, area, area.MinEdge, area.MinEdge, area.getExtent());
- delete[] data;
-}
-
void MeshMakeData::setCrack(int crack_level, v3s16 crack_pos)
{
if (crack_level >= 0)
static u8 getInteriorLight(enum LightBank bank, MapNode n, s32 increment,
const NodeDefManager *ndef)
{
- u8 light = n.getLight(bank, ndef);
- if (light > 0)
- light = rangelim(light + increment, 0, LIGHT_SUN);
+ u8 light = n.getLight(bank, ndef->getLightingFlags(n));
+ light = rangelim(light + increment, 0, LIGHT_SUN);
return decode_light(light);
}
static u8 getFaceLight(enum LightBank bank, MapNode n, MapNode n2,
v3s16 face_dir, const NodeDefManager *ndef)
{
+ ContentLightingFlags f1 = ndef->getLightingFlags(n);
+ ContentLightingFlags f2 = ndef->getLightingFlags(n2);
+
u8 light;
- u8 l1 = n.getLight(bank, ndef);
- u8 l2 = n2.getLight(bank, ndef);
+ u8 l1 = n.getLight(bank, f1);
+ u8 l2 = n2.getLight(bank, f2);
if(l1 > l2)
light = l1;
else
light = l2;
// Boost light level for light sources
- u8 light_source = MYMAX(ndef->get(n).light_source,
- ndef->get(n2).light_source);
+ u8 light_source = MYMAX(f1.light_source, f2.light_source);
if(light_source > light)
light = light_source;
light_source_max = f.light_source;
// Check f.solidness because fast-style leaves look better this way
if (f.param_type == CPT_LIGHT && f.solidness != 2) {
- u8 light_level_day = n.getLightNoChecks(LIGHTBANK_DAY, &f);
- u8 light_level_night = n.getLightNoChecks(LIGHTBANK_NIGHT, &f);
+ u8 light_level_day = n.getLight(LIGHTBANK_DAY, f.getLightingFlags());
+ u8 light_level_night = n.getLight(LIGHTBANK_NIGHT, f.getLightingFlags());
if (light_level_day == LIGHT_SUN)
direct_sunlight = true;
light_day += decode_light(light_level_day);
return f.light_propagates;
};
- std::array<bool, 4> obstructed = {{ 1, 1, 1, 1 }};
+ bool obstructed[4] = { true, true, true, true };
add_node(0);
bool opaque1 = !add_node(1);
bool opaque2 = !add_node(2);
Mesh generation helpers
*/
+// This table is moved outside getNodeVertexDirs to avoid the compiler using
+// a mutex to initialize this table at runtime right in the hot path.
+// For details search the internet for "cxa_guard_acquire".
+static const v3s16 vertex_dirs_table[] = {
+ // ( 1, 0, 0)
+ v3s16( 1,-1, 1), v3s16( 1,-1,-1),
+ v3s16( 1, 1,-1), v3s16( 1, 1, 1),
+ // ( 0, 1, 0)
+ v3s16( 1, 1,-1), v3s16(-1, 1,-1),
+ v3s16(-1, 1, 1), v3s16( 1, 1, 1),
+ // ( 0, 0, 1)
+ v3s16(-1,-1, 1), v3s16( 1,-1, 1),
+ v3s16( 1, 1, 1), v3s16(-1, 1, 1),
+ // invalid
+ v3s16(), v3s16(), v3s16(), v3s16(),
+ // ( 0, 0,-1)
+ v3s16( 1,-1,-1), v3s16(-1,-1,-1),
+ v3s16(-1, 1,-1), v3s16( 1, 1,-1),
+ // ( 0,-1, 0)
+ v3s16( 1,-1, 1), v3s16(-1,-1, 1),
+ v3s16(-1,-1,-1), v3s16( 1,-1,-1),
+ // (-1, 0, 0)
+ v3s16(-1,-1,-1), v3s16(-1,-1, 1),
+ v3s16(-1, 1, 1), v3s16(-1, 1,-1)
+};
+
/*
vertex_dirs: v3s16[4]
*/
2: top-left
3: top-right
*/
- if (dir == v3s16(0, 0, 1)) {
- // If looking towards z+, this is the face that is behind
- // the center point, facing towards z+.
- vertex_dirs[0] = v3s16(-1,-1, 1);
- vertex_dirs[1] = v3s16( 1,-1, 1);
- vertex_dirs[2] = v3s16( 1, 1, 1);
- vertex_dirs[3] = v3s16(-1, 1, 1);
- } else if (dir == v3s16(0, 0, -1)) {
- // faces towards Z-
- vertex_dirs[0] = v3s16( 1,-1,-1);
- vertex_dirs[1] = v3s16(-1,-1,-1);
- vertex_dirs[2] = v3s16(-1, 1,-1);
- vertex_dirs[3] = v3s16( 1, 1,-1);
- } else if (dir == v3s16(1, 0, 0)) {
- // faces towards X+
- vertex_dirs[0] = v3s16( 1,-1, 1);
- vertex_dirs[1] = v3s16( 1,-1,-1);
- vertex_dirs[2] = v3s16( 1, 1,-1);
- vertex_dirs[3] = v3s16( 1, 1, 1);
- } else if (dir == v3s16(-1, 0, 0)) {
- // faces towards X-
- vertex_dirs[0] = v3s16(-1,-1,-1);
- vertex_dirs[1] = v3s16(-1,-1, 1);
- vertex_dirs[2] = v3s16(-1, 1, 1);
- vertex_dirs[3] = v3s16(-1, 1,-1);
- } else if (dir == v3s16(0, 1, 0)) {
- // faces towards Y+ (assume Z- as "down" in texture)
- vertex_dirs[0] = v3s16( 1, 1,-1);
- vertex_dirs[1] = v3s16(-1, 1,-1);
- vertex_dirs[2] = v3s16(-1, 1, 1);
- vertex_dirs[3] = v3s16( 1, 1, 1);
- } else if (dir == v3s16(0, -1, 0)) {
- // faces towards Y- (assume Z+ as "down" in texture)
- vertex_dirs[0] = v3s16( 1,-1, 1);
- vertex_dirs[1] = v3s16(-1,-1, 1);
- vertex_dirs[2] = v3s16(-1,-1,-1);
- vertex_dirs[3] = v3s16( 1,-1,-1);
- }
+
+ // Direction must be (1,0,0), (-1,0,0), (0,1,0), (0,-1,0),
+ // (0,0,1), (0,0,-1)
+ assert(dir.X * dir.X + dir.Y * dir.Y + dir.Z * dir.Z == 1);
+
+ // Convert direction to single integer for table lookup
+ u8 idx = (dir.X + 2 * dir.Y + 3 * dir.Z) & 7;
+ idx = (idx - 1) * 4;
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#if __GNUC__ > 7
+#pragma GCC diagnostic ignored "-Wclass-memaccess"
+#endif
+#endif
+ memcpy(vertex_dirs, &vertex_dirs_table[idx], 4 * sizeof(v3s16));
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
}
static void getNodeTextureCoords(v3f base, const v3f &scale, const v3s16 &dir, float *u, float *v)
{
- if (dir.X > 0 || dir.Y > 0 || dir.Z < 0)
+ if (dir.X > 0 || dir.Y != 0 || dir.Z < 0)
base -= scale;
if (dir == v3s16(0,0,1)) {
- *u = -base.X - 1;
- *v = -base.Y - 1;
+ *u = -base.X;
+ *v = -base.Y;
} else if (dir == v3s16(0,0,-1)) {
*u = base.X + 1;
- *v = -base.Y - 2;
+ *v = -base.Y - 1;
} else if (dir == v3s16(1,0,0)) {
*u = base.Z + 1;
- *v = -base.Y - 2;
- } else if (dir == v3s16(-1,0,0)) {
- *u = -base.Z - 1;
*v = -base.Y - 1;
+ } else if (dir == v3s16(-1,0,0)) {
+ *u = -base.Z;
+ *v = -base.Y;
} else if (dir == v3s16(0,1,0)) {
*u = base.X + 1;
- *v = -base.Z - 2;
+ *v = -base.Z - 1;
} else if (dir == v3s16(0,-1,0)) {
- *u = base.X;
- *v = base.Z;
+ *u = base.X + 1;
+ *v = base.Z + 1;
}
}
const ContentFeatures &f2 = ndef->get(m2);
// Contents don't differ for different forms of same liquid
- if (f1.sameLiquid(f2))
+ if (f1.sameLiquidRender(f2))
return 0;
u8 c1 = f1.solidness;
if (c1 == c2) {
*equivalent = true;
// If same solidness, liquid takes precense
- if (f1.isLiquid())
+ if (f1.isLiquidRender())
return 1;
- if (f2.isLiquid())
+ if (f2.isLiquidRender())
return 2;
}
v3s16 &p_corrected,
v3s16 &face_dir_corrected,
u16 *lights,
+ u8 &waving,
TileSpec &tile
)
{
getNodeTile(n, p_corrected, face_dir_corrected, data, tile);
const ContentFeatures &f = ndef->get(n);
+ waving = f.waving;
tile.emissive_light = f.light_source;
// eg. water and glass
const v3s16 &&face_dir,
std::vector<FastFace> &dest)
{
+ static thread_local const bool waving_liquids =
+ g_settings->getBool("enable_shaders") &&
+ g_settings->getBool("enable_waving_water");
+
+ static thread_local const bool force_not_tiling =
+ g_settings->getBool("enable_dynamic_shadows");
+
v3s16 p = startpos;
u16 continuous_tiles_count = 1;
v3s16 p_corrected;
v3s16 face_dir_corrected;
u16 lights[4] = {0, 0, 0, 0};
+ u8 waving = 0;
TileSpec tile;
+
+ // Get info of first tile
getTileInfo(data, p, face_dir,
makes_face, p_corrected, face_dir_corrected,
- lights, tile);
+ lights, waving, tile);
// 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;
- v3s16 p_next;
-
bool next_makes_face = false;
v3s16 next_p_corrected;
v3s16 next_face_dir_corrected;
// If at last position, there is nothing to compare to and
// the face must be drawn anyway
- if (j != MAP_BLOCKSIZE - 1) {
- p_next = p + translate_dir;
+ if (j != data->side_length - 1) {
+ p += translate_dir;
- getTileInfo(data, p_next, face_dir,
+ getTileInfo(data, p, face_dir,
next_makes_face, next_p_corrected,
next_face_dir_corrected, next_lights,
+ waving,
next_tile);
- if (next_makes_face == makes_face
+ if (!force_not_tiling
+ && next_makes_face == makes_face
&& next_p_corrected == p_corrected + translate_dir
&& next_face_dir_corrected == face_dir_corrected
- && memcmp(next_lights, lights, ARRLEN(lights) * sizeof(u16)) == 0
+ && memcmp(next_lights, lights, sizeof(lights)) == 0
+ // Don't apply fast faces to waving water.
+ && (waving != 3 || !waving_liquids)
&& next_tile.isTileable(tile)) {
next_is_different = false;
continuous_tiles_count++;
makeFastFace(tile, lights[0], lights[1], lights[2], lights[3],
pf, sp, face_dir_corrected, scale, dest);
-
- g_profiler->avg("Meshgen: faces drawn by tiling", 0);
- for (int i = 1; i < continuous_tiles_count; i++)
- g_profiler->avg("Meshgen: faces drawn by tiling", 1);
+ g_profiler->avg("Meshgen: Tiles per face [#]", continuous_tiles_count);
}
continuous_tiles_count = 1;
makes_face = next_makes_face;
p_corrected = next_p_corrected;
face_dir_corrected = next_face_dir_corrected;
- std::memcpy(lights, next_lights, ARRLEN(lights) * sizeof(u16));
+ memcpy(lights, next_lights, sizeof(lights));
if (next_is_different)
- tile = next_tile;
- p = p_next;
+ tile = std::move(next_tile); // faster than copy
}
}
/*
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, u16 side_length)
+{
+ this->triangles = triangles;
+
+ nodes.clear();
+
+ // assert that triangle index can fit into s32
+ assert(triangles->size() <= 0x7FFFFFFFL);
+ std::vector<s32> indexes;
+ indexes.reserve(triangles->size());
+ for (u32 i = 0; i < triangles->size(); i++)
+ indexes.push_back(i);
+
+ 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((side_length + 1) * 0.5f * BS), side_length * 0.25f * BS, indexes, 0);
+ } else {
+ root = -1;
+ }
+}
+
+/**
+ * @brief Find a candidate plane to split a set of triangles in two
+ *
+ * The candidate plane is represented by one of the triangles from the set.
+ *
+ * @param list Vector of indexes of the triangles in the set
+ * @param triangles Vector of all triangles in the BSP tree
+ * @return Address of the triangle that represents the proposed split plane
+ */
+static const MeshTriangle *findSplitCandidate(const std::vector<s32> &list, const std::vector<MeshTriangle> &triangles)
+{
+ // find the center of the cluster.
+ v3f center(0, 0, 0);
+ size_t n = list.size();
+ for (s32 i : list) {
+ center += triangles[i].centroid / n;
+ }
+
+ // find the triangle with the largest area and closest to the center
+ const MeshTriangle *candidate_triangle = &triangles[list[0]];
+ const MeshTriangle *ith_triangle;
+ for (s32 i : list) {
+ ith_triangle = &triangles[i];
+ if (ith_triangle->areaSQ > candidate_triangle->areaSQ ||
+ (ith_triangle->areaSQ == candidate_triangle->areaSQ &&
+ ith_triangle->centroid.getDistanceFromSQ(center) < candidate_triangle->centroid.getDistanceFromSQ(center))) {
+ candidate_triangle = ith_triangle;
+ }
+ }
+ return candidate_triangle;
+}
+
+s32 MapBlockBspTree::buildTree(v3f normal, v3f origin, float delta, const std::vector<s32> &list, u32 depth)
+{
+ // if the list is empty, don't bother
+ if (list.empty())
+ return -1;
+
+ // if there is only one triangle, or the delta is insanely small, this is a leaf node
+ if (list.size() == 1 || delta < 0.01) {
+ nodes.emplace_back(normal, origin, list, -1, -1);
+ return nodes.size() - 1;
+ }
+
+ std::vector<s32> front_list;
+ std::vector<s32> back_list;
+ std::vector<s32> node_list;
+
+ // split the list
+ for (s32 i : list) {
+ const MeshTriangle &triangle = (*triangles)[i];
+ float factor = normal.dotProduct(triangle.centroid - origin);
+ if (factor == 0)
+ node_list.push_back(i);
+ else if (factor > 0)
+ front_list.push_back(i);
+ else
+ back_list.push_back(i);
+ }
+
+ // define the new split-plane
+ v3f candidate_normal(normal.Z, normal.X, normal.Y);
+ float candidate_delta = delta;
+ if (depth % 3 == 2)
+ candidate_delta /= 2;
+
+ s32 front_index = -1;
+ s32 back_index = -1;
+
+ if (!front_list.empty()) {
+ v3f next_normal = candidate_normal;
+ v3f next_origin = origin + delta * normal;
+ float next_delta = candidate_delta;
+ if (next_delta < 5) {
+ const MeshTriangle *candidate = findSplitCandidate(front_list, *triangles);
+ next_normal = candidate->getNormal();
+ next_origin = candidate->centroid;
+ }
+ front_index = buildTree(next_normal, next_origin, next_delta, front_list, depth + 1);
+
+ // if there are no other triangles, don't create a new node
+ if (back_list.empty() && node_list.empty())
+ return front_index;
+ }
+
+ if (!back_list.empty()) {
+ v3f next_normal = candidate_normal;
+ v3f next_origin = origin - delta * normal;
+ float next_delta = candidate_delta;
+ if (next_delta < 5) {
+ const MeshTriangle *candidate = findSplitCandidate(back_list, *triangles);
+ next_normal = candidate->getNormal();
+ next_origin = candidate->centroid;
+ }
+
+ back_index = buildTree(next_normal, next_origin, next_delta, back_list, depth + 1);
+
+ // if there are no other triangles, don't create a new node
+ if (front_list.empty() && node_list.empty())
+ return back_index;
+ }
+
+ nodes.emplace_back(normal, origin, node_list, front_index, back_index);
+
+ return nodes.size() - 1;
+}
+
+void MapBlockBspTree::traverse(s32 node, v3f viewpoint, std::vector<s32> &output) const
+{
+ if (node < 0) return; // recursion break;
+
+ const TreeNode &n = nodes[node];
+ float factor = n.normal.dotProduct(viewpoint - n.origin);
+
+ if (factor > 0)
+ traverse(n.back_ref, viewpoint, output);
+ else
+ traverse(n.front_ref, viewpoint, output);
+
+ if (factor != 0)
+ for (s32 i : n.triangle_refs)
+ output.push_back(i);
+
+ if (factor > 0)
+ traverse(n.front_ref, viewpoint, output);
+ else
+ traverse(n.back_ref, viewpoint, output);
+}
+
+
+
+/*
+ PartialMeshBuffer
+*/
+
+void PartialMeshBuffer::beforeDraw() const
+{
+ // Patch the indexes in the mesh buffer before draw
+ m_buffer->Indices = std::move(m_vertex_indexes);
+ m_buffer->setDirty(scene::EBT_INDEX);
+}
+
+void PartialMeshBuffer::afterDraw() const
+{
+ // Take the data back
+ m_vertex_indexes = m_buffer->Indices.steal();
+}
+
/*
MapBlockMesh
*/
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
for (auto &m : m_mesh)
m = new scene::SMesh();
m_enable_shaders = data->m_use_shaders;
- m_use_tangent_vertices = data->m_use_tangent_vertices;
m_enable_vbo = g_settings->getBool("enable_vbo");
- if (g_settings->getBool("enable_minimap")) {
- 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 (data->m_mesh_grid.isMeshPos(bp) && data->m_client->getMinimap()) {
+ m_minimap_mapblocks.resize(data->m_mesh_grid.getCellVolume(), nullptr);
+ v3s16 ofs;
+
+ // See also client.cpp for the code that reads the array of minimap blocks.
+ for (ofs.Z = 0; ofs.Z < data->m_mesh_grid.cell_size; ofs.Z++)
+ for (ofs.Y = 0; ofs.Y < data->m_mesh_grid.cell_size; ofs.Y++)
+ for (ofs.X = 0; ofs.X < data->m_mesh_grid.cell_size; ofs.X++) {
+ v3s16 p = (bp + ofs) * MAP_BLOCKSIZE;
+ if (data->m_vmanip.getNodeNoEx(p).getContent() != CONTENT_IGNORE) {
+ MinimapMapblock *block = new MinimapMapblock;
+ m_minimap_mapblocks[data->m_mesh_grid.getOffsetIndex(ofs)] = block;
+ block->getMinimapNodes(&data->m_vmanip, p);
+ }
+ }
}
// 4-21ms for MAP_BLOCKSIZE=16 (NOTE: probably outdated)
Convert FastFaces to MeshCollector
*/
- MeshCollector collector;
+ v3f offset = intToFloat((data->m_blockpos - data->m_mesh_grid.getMeshPos(data->m_blockpos)) * MAP_BLOCKSIZE, BS);
+ MeshCollector collector(m_bounding_sphere_center, offset);
{
// avg 0ms (100ms spikes when loading textures the first time)
*/
{
- MapblockMeshGenerator generator(data, &collector);
- generator.generate();
+ MapblockMeshGenerator(data, &collector,
+ data->m_client->getSceneManager()->getMeshManipulator()).generate();
}
/*
Convert MeshCollector to SMesh
*/
+ const bool desync_animations = g_settings->getBool(
+ "desynchronize_mapblock_texture_animation");
+
+ m_bounding_radius = std::sqrt(collector.m_bounding_radius_sq);
+
for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
for(u32 i = 0; i < collector.prebuffers[layer].size(); i++)
{
// - Texture animation
if (p.layer.material_flags & MATERIAL_FLAG_ANIMATION) {
// Add to MapBlockMesh in order to animate these tiles
- m_animation_tiles[std::pair<u8, u32>(layer, i)] = p.layer;
- m_animation_frames[std::pair<u8, u32>(layer, i)] = 0;
- if (g_settings->getBool(
- "desynchronize_mapblock_texture_animation")) {
+ auto &info = m_animation_info[{layer, i}];
+ info.tile = p.layer;
+ info.frame = 0;
+ if (desync_animations) {
// Get starting position from noise
- m_animation_frame_offsets[std::pair<u8, u32>(layer, i)] =
+ info.frame_offset =
100000 * (2.0 + noise3d(
data->m_blockpos.X, data->m_blockpos.Y,
data->m_blockpos.Z, 0));
} else {
// Play all synchronized
- m_animation_frame_offsets[std::pair<u8, u32>(layer, i)] = 0;
+ info.frame_offset = 0;
}
// Replace tile texture with the first animation frame
p.layer.texture = (*p.layer.frames)[0].texture;
// Dummy sunlight to handle non-sunlit areas
video::SColorf sunlight;
get_sunlight_color(&sunlight, 0);
- u32 vertex_count = p.vertices.size();
+
+ std::map<u32, video::SColor> colors;
+ const u32 vertex_count = p.vertices.size();
for (u32 j = 0; j < vertex_count; j++) {
video::SColor *vc = &p.vertices[j].Color;
video::SColor copy = *vc;
if (vc->getAlpha() == 0) // No sunlight - no need to animate
final_color_blend(vc, copy, sunlight); // Finalize color
else // Record color to animate
- m_daynight_diffs[std::pair<u8, u32>(layer, i)][j] = copy;
+ colors[j] = copy;
// The sunlight ratio has been stored,
// delete alpha (for the final rendering).
vc->setAlpha(255);
}
+ if (!colors.empty())
+ m_daynight_diffs[{layer, i}] = std::move(colors);
}
// Create material
scene::SMesh *mesh = (scene::SMesh *)m_mesh[layer];
- // Create meshbuffer, add to mesh
- if (m_use_tangent_vertices) {
- scene::SMeshBufferTangents *buf =
- new scene::SMeshBufferTangents();
- buf->Material = material;
- buf->Vertices.reallocate(p.vertices.size());
- buf->Indices.reallocate(p.indices.size());
- for (const video::S3DVertex &v: p.vertices)
- buf->Vertices.push_back(video::S3DVertexTangents(v.Pos, v.Color, v.TCoords));
- for (u16 i: p.indices)
- buf->Indices.push_back(i);
- buf->recalculateBoundingBox();
- mesh->addMeshBuffer(buf);
- buf->drop();
+ scene::SMeshBuffer *buf = new scene::SMeshBuffer();
+ buf->Material = material;
+ if (p.layer.isTransparent()) {
+ buf->append(&p.vertices[0], p.vertices.size(), nullptr, 0);
+
+ MeshTriangle t;
+ t.buffer = buf;
+ m_transparent_triangles.reserve(p.indices.size() / 3);
+ for (u32 i = 0; i < p.indices.size(); i += 3) {
+ t.p1 = p.indices[i];
+ t.p2 = p.indices[i + 1];
+ t.p3 = p.indices[i + 2];
+ t.updateAttributes();
+ m_transparent_triangles.push_back(t);
+ }
} else {
- scene::SMeshBuffer *buf = new scene::SMeshBuffer();
- buf->Material = material;
buf->append(&p.vertices[0], p.vertices.size(),
&p.indices[0], p.indices.size());
- mesh->addMeshBuffer(buf);
- buf->drop();
}
- }
-
- /*
- Do some stuff to the mesh
- */
- m_camera_offset = camera_offset;
- translateMesh(m_mesh[layer],
- intToFloat(data->m_blockpos * MAP_BLOCKSIZE - camera_offset, BS));
-
- if (m_use_tangent_vertices) {
- scene::IMeshManipulator* meshmanip =
- RenderingEngine::get_scene_manager()->getMeshManipulator();
- meshmanip->recalculateTangents(m_mesh[layer], true, false, false);
+ mesh->addMeshBuffer(buf);
+ buf->drop();
}
if (m_mesh[layer]) {
-#if 0
- // Usually 1-700 faces and 1-7 materials
- std::cout << "Updated MapBlock has " << fastfaces_new.size()
- << " faces and uses " << m_mesh[layer]->getMeshBufferCount()
- << " materials (meshbuffers)" << std::endl;
-#endif
-
// Use VBO for mesh (this just would set this for ever buffer)
if (m_enable_vbo)
m_mesh[layer]->setHardwareMappingHint(scene::EHM_STATIC);
}
//std::cout<<"added "<<fastfaces.getSize()<<" faces."<<std::endl;
+ m_bsp_tree.buildTree(&m_transparent_triangles, data->side_length);
// Check if animation is required for this mesh
m_has_animation =
!m_crack_materials.empty() ||
!m_daynight_diffs.empty() ||
- !m_animation_tiles.empty();
+ !m_animation_info.empty();
}
MapBlockMesh::~MapBlockMesh()
{
for (scene::IMesh *m : m_mesh) {
- if (m_enable_vbo && m)
- for (u32 i = 0; i < m->getMeshBufferCount(); i++) {
- scene::IMeshBuffer *buf = m->getMeshBuffer(i);
- RenderingEngine::get_video_driver()->removeHardwareBuffer(buf);
- }
m->drop();
- m = NULL;
}
- delete m_minimap_mapblock;
+ for (MinimapMapblock *block : m_minimap_mapblocks)
+ delete block;
}
bool MapBlockMesh::animate(bool faraway, float time, int crack,
for (auto &crack_material : m_crack_materials) {
scene::IMeshBuffer *buf = m_mesh[crack_material.first.first]->
getMeshBuffer(crack_material.first.second);
- std::string basename = crack_material.second;
// Create new texture name from original
- std::ostringstream os;
- os << basename << crack;
+ std::string s = crack_material.second + itos(crack);
u32 new_texture_id = 0;
video::ITexture *new_texture =
- m_tsrc->getTextureForMesh(os.str(), &new_texture_id);
+ m_tsrc->getTextureForMesh(s, &new_texture_id);
buf->getMaterial().setTexture(0, new_texture);
- // If the current material is also animated,
- // update animation info
- auto anim_iter = m_animation_tiles.find(crack_material.first);
- if (anim_iter != m_animation_tiles.end()) {
- TileLayer &tile = anim_iter->second;
+ // If the current material is also animated, update animation info
+ auto anim_it = m_animation_info.find(crack_material.first);
+ if (anim_it != m_animation_info.end()) {
+ TileLayer &tile = anim_it->second.tile;
tile.texture = new_texture;
tile.texture_id = new_texture_id;
// force animation update
- m_animation_frames[crack_material.first] = -1;
+ anim_it->second.frame = -1;
}
}
}
// Texture animation
- for (auto &animation_tile : m_animation_tiles) {
- const TileLayer &tile = animation_tile.second;
+ for (auto &it : m_animation_info) {
+ const TileLayer &tile = it.second.tile;
// Figure out current frame
- int frameoffset = m_animation_frame_offsets[animation_tile.first];
- int frame = (int)(time * 1000 / tile.animation_frame_length_ms
- + frameoffset) % tile.animation_frame_count;
+ int frameno = (int)(time * 1000 / tile.animation_frame_length_ms
+ + it.second.frame_offset) % tile.animation_frame_count;
// If frame doesn't change, skip
- if (frame == m_animation_frames[animation_tile.first])
+ if (frameno == it.second.frame)
continue;
- m_animation_frames[animation_tile.first] = frame;
+ it.second.frame = frameno;
- scene::IMeshBuffer *buf = m_mesh[animation_tile.first.first]->
- getMeshBuffer(animation_tile.first.second);
+ scene::IMeshBuffer *buf = m_mesh[it.first.first]->getMeshBuffer(it.first.second);
- const FrameSpec &animation_frame = (*tile.frames)[frame];
- buf->getMaterial().setTexture(0, animation_frame.texture);
+ const FrameSpec &frame = (*tile.frames)[frameno];
+ buf->getMaterial().setTexture(0, frame.texture);
if (m_enable_shaders) {
- if (animation_frame.normal_texture)
- buf->getMaterial().setTexture(1,
- animation_frame.normal_texture);
- buf->getMaterial().setTexture(2, animation_frame.flags_texture);
+ if (frame.normal_texture)
+ buf->getMaterial().setTexture(1, frame.normal_texture);
+ buf->getMaterial().setTexture(2, frame.flags_texture);
}
}
return true;
}
-void MapBlockMesh::updateCameraOffset(v3s16 camera_offset)
+void MapBlockMesh::updateTransparentBuffers(v3f camera_pos, v3s16 block_pos)
{
- if (camera_offset != m_camera_offset) {
- for (scene::IMesh *layer : m_mesh) {
- translateMesh(layer,
- intToFloat(m_camera_offset - camera_offset, BS));
- if (m_enable_vbo)
- layer->setDirty();
+ // nothing to do if the entire block is opaque
+ if (m_transparent_triangles.empty())
+ return;
+
+ v3f block_posf = intToFloat(block_pos * MAP_BLOCKSIZE, BS);
+ v3f rel_camera_pos = camera_pos - block_posf;
+
+ std::vector<s32> triangle_refs;
+ m_bsp_tree.traverse(rel_camera_pos, triangle_refs);
+
+ // arrange index sequences into partial buffers
+ m_transparent_buffers.clear();
+
+ scene::SMeshBuffer *current_buffer = nullptr;
+ std::vector<u16> current_strain;
+ for (auto i : triangle_refs) {
+ const auto &t = m_transparent_triangles[i];
+ if (current_buffer != t.buffer) {
+ if (current_buffer) {
+ m_transparent_buffers.emplace_back(current_buffer, std::move(current_strain));
+ current_strain.clear();
+ }
+ current_buffer = t.buffer;
}
- m_camera_offset = camera_offset;
+ current_strain.push_back(t.p1);
+ current_strain.push_back(t.p2);
+ current_strain.push_back(t.p3);
+ }
+
+ if (!current_strain.empty())
+ m_transparent_buffers.emplace_back(current_buffer, std::move(current_strain));
+}
+
+void MapBlockMesh::consolidateTransparentBuffers()
+{
+ m_transparent_buffers.clear();
+
+ scene::SMeshBuffer *current_buffer = nullptr;
+ std::vector<u16> current_strain;
+
+ // use the fact that m_transparent_triangles is already arranged by buffer
+ for (const auto &t : m_transparent_triangles) {
+ if (current_buffer != t.buffer) {
+ if (current_buffer != nullptr) {
+ this->m_transparent_buffers.emplace_back(current_buffer, std::move(current_strain));
+ current_strain.clear();
+ }
+ current_buffer = t.buffer;
+ }
+ current_strain.push_back(t.p1);
+ current_strain.push_back(t.p2);
+ current_strain.push_back(t.p3);
+ }
+
+ if (!current_strain.empty()) {
+ this->m_transparent_buffers.emplace_back(current_buffer, std::move(current_strain));
}
}
float b = (day + night) / 2;
return video::SColor(r, b, b, b);
}
+
+std::unordered_map<v3s16, u8> get_solid_sides(MeshMakeData *data)
+{
+ std::unordered_map<v3s16, u8> results;
+ v3s16 ofs;
+ const u16 mesh_chunk = data->side_length / MAP_BLOCKSIZE;
+
+ for (ofs.X = 0; ofs.X < mesh_chunk; ofs.X++)
+ for (ofs.Y = 0; ofs.Y < mesh_chunk; ofs.Y++)
+ for (ofs.Z = 0; ofs.Z < mesh_chunk; 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);
+ }
+ }
+
+ results[blockpos] = result;
+ }
+ return results;
+}