// Corresponding offsets are listed in g_27dirs
#define FRAMED_NEIGHBOR_COUNT 18
+// Maps light index to corner direction
static const v3s16 light_dirs[8] = {
v3s16(-1, -1, -1),
v3s16(-1, -1, 1),
v3s16( 1, 1, 1),
};
+// Maps cuboid face and vertex indices to the corresponding light index
+static const u8 light_indices[6][4] = {
+ {3, 7, 6, 2},
+ {0, 4, 5, 1},
+ {6, 7, 5, 4},
+ {3, 2, 0, 1},
+ {7, 3, 1, 5},
+ {2, 6, 4, 0},
+};
+
// Standard index set to make a quad on 4 vertices
-static constexpr u16 quad_indices[] = {0, 1, 2, 2, 3, 0};
+static constexpr u16 quad_indices_02[] = {0, 1, 2, 2, 3, 0};
+static constexpr u16 quad_indices_13[] = {0, 1, 3, 3, 1, 2};
+static const auto &quad_indices = quad_indices_02;
const std::string MapblockMeshGenerator::raillike_groupname = "connect_to_raillike";
collector->append(tile, vertices, 4, quad_indices, 6);
}
-// Create a cuboid.
-// tiles - the tiles (materials) to use (for all 6 faces)
-// tilecount - number of entries in tiles, 1<=tilecount<=6
-// lights - vertex light levels. The order is the same as in light_dirs.
-// NULL may be passed if smooth lighting is disabled.
-// txc - texture coordinates - this is a list of texture coordinates
-// for the opposite corners of each face - therefore, there
-// should be (2+2)*6=24 values in the list. The order of
-// the faces in the list is up-down-right-left-back-front
-// (compatible with ContentFeatures).
-// mask - a bit mask that suppresses drawing of tiles.
-// tile i will not be drawn if mask & (1 << i) is 1
-void MapblockMeshGenerator::drawCuboid(const aabb3f &box,
- TileSpec *tiles, int tilecount, const LightInfo *lights, const f32 *txc, u8 mask)
-{
- assert(tilecount >= 1 && tilecount <= 6); // pre-condition
-
+static std::array<video::S3DVertex, 24> setupCuboidVertices(const aabb3f &box, const f32 *txc, TileSpec *tiles, int tilecount) {
v3f min = box.MinEdge;
v3f max = box.MaxEdge;
- video::SColor colors[6];
- if (!data->m_smooth_lighting) {
- for (int face = 0; face != 6; ++face) {
- colors[face] = encode_light(light, f->light_source);
- }
- if (!f->light_source) {
- applyFacesShading(colors[0], v3f(0, 1, 0));
- applyFacesShading(colors[1], v3f(0, -1, 0));
- applyFacesShading(colors[2], v3f(1, 0, 0));
- applyFacesShading(colors[3], v3f(-1, 0, 0));
- applyFacesShading(colors[4], v3f(0, 0, 1));
- applyFacesShading(colors[5], v3f(0, 0, -1));
- }
- }
-
- video::S3DVertex vertices[24] = {
+ std::array<video::S3DVertex, 24> vertices = {{
// top
- video::S3DVertex(min.X, max.Y, max.Z, 0, 1, 0, colors[0], txc[0], txc[1]),
- video::S3DVertex(max.X, max.Y, max.Z, 0, 1, 0, colors[0], txc[2], txc[1]),
- video::S3DVertex(max.X, max.Y, min.Z, 0, 1, 0, colors[0], txc[2], txc[3]),
- video::S3DVertex(min.X, max.Y, min.Z, 0, 1, 0, colors[0], txc[0], txc[3]),
+ video::S3DVertex(min.X, max.Y, max.Z, 0, 1, 0, {}, txc[0], txc[1]),
+ video::S3DVertex(max.X, max.Y, max.Z, 0, 1, 0, {}, txc[2], txc[1]),
+ video::S3DVertex(max.X, max.Y, min.Z, 0, 1, 0, {}, txc[2], txc[3]),
+ video::S3DVertex(min.X, max.Y, min.Z, 0, 1, 0, {}, txc[0], txc[3]),
// bottom
- video::S3DVertex(min.X, min.Y, min.Z, 0, -1, 0, colors[1], txc[4], txc[5]),
- video::S3DVertex(max.X, min.Y, min.Z, 0, -1, 0, colors[1], txc[6], txc[5]),
- video::S3DVertex(max.X, min.Y, max.Z, 0, -1, 0, colors[1], txc[6], txc[7]),
- video::S3DVertex(min.X, min.Y, max.Z, 0, -1, 0, colors[1], txc[4], txc[7]),
+ video::S3DVertex(min.X, min.Y, min.Z, 0, -1, 0, {}, txc[4], txc[5]),
+ video::S3DVertex(max.X, min.Y, min.Z, 0, -1, 0, {}, txc[6], txc[5]),
+ video::S3DVertex(max.X, min.Y, max.Z, 0, -1, 0, {}, txc[6], txc[7]),
+ video::S3DVertex(min.X, min.Y, max.Z, 0, -1, 0, {}, txc[4], txc[7]),
// right
- video::S3DVertex(max.X, max.Y, min.Z, 1, 0, 0, colors[2], txc[ 8], txc[9]),
- video::S3DVertex(max.X, max.Y, max.Z, 1, 0, 0, colors[2], txc[10], txc[9]),
- video::S3DVertex(max.X, min.Y, max.Z, 1, 0, 0, colors[2], txc[10], txc[11]),
- video::S3DVertex(max.X, min.Y, min.Z, 1, 0, 0, colors[2], txc[ 8], txc[11]),
+ video::S3DVertex(max.X, max.Y, min.Z, 1, 0, 0, {}, txc[ 8], txc[9]),
+ video::S3DVertex(max.X, max.Y, max.Z, 1, 0, 0, {}, txc[10], txc[9]),
+ video::S3DVertex(max.X, min.Y, max.Z, 1, 0, 0, {}, txc[10], txc[11]),
+ video::S3DVertex(max.X, min.Y, min.Z, 1, 0, 0, {}, txc[ 8], txc[11]),
// left
- video::S3DVertex(min.X, max.Y, max.Z, -1, 0, 0, colors[3], txc[12], txc[13]),
- video::S3DVertex(min.X, max.Y, min.Z, -1, 0, 0, colors[3], txc[14], txc[13]),
- video::S3DVertex(min.X, min.Y, min.Z, -1, 0, 0, colors[3], txc[14], txc[15]),
- video::S3DVertex(min.X, min.Y, max.Z, -1, 0, 0, colors[3], txc[12], txc[15]),
+ video::S3DVertex(min.X, max.Y, max.Z, -1, 0, 0, {}, txc[12], txc[13]),
+ video::S3DVertex(min.X, max.Y, min.Z, -1, 0, 0, {}, txc[14], txc[13]),
+ video::S3DVertex(min.X, min.Y, min.Z, -1, 0, 0, {}, txc[14], txc[15]),
+ video::S3DVertex(min.X, min.Y, max.Z, -1, 0, 0, {}, txc[12], txc[15]),
// back
- video::S3DVertex(max.X, max.Y, max.Z, 0, 0, 1, colors[4], txc[16], txc[17]),
- video::S3DVertex(min.X, max.Y, max.Z, 0, 0, 1, colors[4], txc[18], txc[17]),
- video::S3DVertex(min.X, min.Y, max.Z, 0, 0, 1, colors[4], txc[18], txc[19]),
- video::S3DVertex(max.X, min.Y, max.Z, 0, 0, 1, colors[4], txc[16], txc[19]),
+ video::S3DVertex(max.X, max.Y, max.Z, 0, 0, 1, {}, txc[16], txc[17]),
+ video::S3DVertex(min.X, max.Y, max.Z, 0, 0, 1, {}, txc[18], txc[17]),
+ video::S3DVertex(min.X, min.Y, max.Z, 0, 0, 1, {}, txc[18], txc[19]),
+ video::S3DVertex(max.X, min.Y, max.Z, 0, 0, 1, {}, txc[16], txc[19]),
// front
- video::S3DVertex(min.X, max.Y, min.Z, 0, 0, -1, colors[5], txc[20], txc[21]),
- video::S3DVertex(max.X, max.Y, min.Z, 0, 0, -1, colors[5], txc[22], txc[21]),
- video::S3DVertex(max.X, min.Y, min.Z, 0, 0, -1, colors[5], txc[22], txc[23]),
- video::S3DVertex(min.X, min.Y, min.Z, 0, 0, -1, colors[5], txc[20], txc[23]),
- };
-
- static const u8 light_indices[24] = {
- 3, 7, 6, 2,
- 0, 4, 5, 1,
- 6, 7, 5, 4,
- 3, 2, 0, 1,
- 7, 3, 1, 5,
- 2, 6, 4, 0
- };
+ video::S3DVertex(min.X, max.Y, min.Z, 0, 0, -1, {}, txc[20], txc[21]),
+ video::S3DVertex(max.X, max.Y, min.Z, 0, 0, -1, {}, txc[22], txc[21]),
+ video::S3DVertex(max.X, min.Y, min.Z, 0, 0, -1, {}, txc[22], txc[23]),
+ video::S3DVertex(min.X, min.Y, min.Z, 0, 0, -1, {}, txc[20], txc[23]),
+ }};
for (int face = 0; face < 6; face++) {
int tileindex = MYMIN(face, tilecount - 1);
}
}
- if (data->m_smooth_lighting) {
- for (int j = 0; j < 24; ++j) {
- video::S3DVertex &vertex = vertices[j];
- vertex.Color = encode_light(
- lights[light_indices[j]].getPair(MYMAX(0.0f, vertex.Normal.Y)),
- f->light_source);
- if (!f->light_source)
- applyFacesShading(vertex.Color, vertex.Normal);
- }
- }
+ return vertices;
+}
+
+enum class QuadDiagonal {
+ Diag02,
+ Diag13,
+};
+
+// Create a cuboid with custom lighting.
+// tiles - the tiles (materials) to use (for all 6 faces)
+// tilecount - number of entries in tiles, 1<=tilecount<=6
+// txc - texture coordinates - this is a list of texture coordinates
+// for the opposite corners of each face - therefore, there
+// should be (2+2)*6=24 values in the list. The order of
+// the faces in the list is up-down-right-left-back-front
+// (compatible with ContentFeatures).
+// mask - a bit mask that suppresses drawing of tiles.
+// tile i will not be drawn if mask & (1 << i) is 1
+// face_lighter(int face, video::S3DVertex vertices[4]) -> QuadDiagonal -
+// a callback that will be called for each face drawn to setup vertex colors,
+// and to choose diagonal to split the quad at.
+template <typename Fn>
+void MapblockMeshGenerator::drawCuboid(const aabb3f &box,
+ TileSpec *tiles, int tilecount, const f32 *txc, u8 mask, Fn &&face_lighter)
+{
+ assert(tilecount >= 1 && tilecount <= 6); // pre-condition
+
+ auto vertices = setupCuboidVertices(box, txc, tiles, tilecount);
- // Add to mesh collector
for (int k = 0; k < 6; ++k) {
if (mask & (1 << k))
continue;
+ QuadDiagonal diagonal = face_lighter(k, &vertices[4 * k]);
+ const u16 *indices = diagonal == QuadDiagonal::Diag13 ? quad_indices_13 : quad_indices_02;
int tileindex = MYMIN(k, tilecount - 1);
- collector->append(tiles[tileindex], vertices + 4 * k, 4, quad_indices, 6);
+ collector->append(tiles[tileindex], &vertices[4 * k], 4, indices, 6);
}
}
coords[i] = txc[i];
}
+static inline int lightDiff(LightPair a, LightPair b)
+{
+ return abs(a.lightDay - b.lightDay) + abs(a.lightNight - b.lightNight);
+}
+
void MapblockMeshGenerator::drawAutoLightedCuboid(aabb3f box, const f32 *txc,
TileSpec *tiles, int tile_count, u8 mask)
{
d.Z = (j & 1) ? dz2 : dz1;
lights[j] = blendLight(d);
}
- drawCuboid(box, tiles, tile_count, lights, txc, mask);
+
+ drawCuboid(box, tiles, tile_count, txc, mask, [&] (int face, video::S3DVertex vertices[4]) {
+ LightPair final_lights[4];
+ for (int j = 0; j < 4; j++) {
+ video::S3DVertex &vertex = vertices[j];
+ final_lights[j] = lights[light_indices[face][j]].getPair(MYMAX(0.0f, vertex.Normal.Y));
+ vertex.Color = encode_light(final_lights[j], f->light_source);
+ if (!f->light_source)
+ applyFacesShading(vertex.Color, vertex.Normal);
+ }
+ if (lightDiff(final_lights[1], final_lights[3]) < lightDiff(final_lights[0], final_lights[2]))
+ return QuadDiagonal::Diag13;
+ return QuadDiagonal::Diag02;
+ });
} else {
- drawCuboid(box, tiles, tile_count, nullptr, txc, mask);
+ drawCuboid(box, tiles, tile_count, txc, mask, [&] (int face, video::S3DVertex vertices[4]) {
+ video::SColor color = encode_light(light, f->light_source);
+ if (!f->light_source)
+ applyFacesShading(color, vertices[0].Normal);
+ for (int j = 0; j < 4; j++) {
+ video::S3DVertex &vertex = vertices[j];
+ vertex.Color = color;
+ }
+ return QuadDiagonal::Diag02;
+ });
+ }
+}
+
+void MapblockMeshGenerator::drawSolidNode()
+{
+ u8 faces = 0; // k-th bit will be set if k-th face is to be drawn.
+ static const v3s16 tile_dirs[6] = {
+ v3s16(0, 1, 0),
+ v3s16(0, -1, 0),
+ v3s16(1, 0, 0),
+ v3s16(-1, 0, 0),
+ v3s16(0, 0, 1),
+ v3s16(0, 0, -1)
+ };
+ TileSpec tiles[6];
+ u16 lights[6];
+ content_t n1 = n.getContent();
+ for (int face = 0; face < 6; face++) {
+ v3s16 p2 = blockpos_nodes + p + tile_dirs[face];
+ MapNode neighbor = data->m_vmanip.getNodeNoEx(p2);
+ content_t n2 = neighbor.getContent();
+ bool backface_culling = f->drawtype == NDT_NORMAL;
+ if (n2 == n1)
+ continue;
+ if (n2 == CONTENT_IGNORE)
+ continue;
+ if (n2 != CONTENT_AIR) {
+ const ContentFeatures &f2 = nodedef->get(n2);
+ if (f2.solidness == 2)
+ continue;
+ if (f->drawtype == NDT_LIQUID) {
+ if (n2 == nodedef->getId(f->liquid_alternative_flowing))
+ continue;
+ if (n2 == nodedef->getId(f->liquid_alternative_source))
+ continue;
+ backface_culling = f2.solidness >= 1;
+ }
+ }
+ faces |= 1 << face;
+ getTile(tile_dirs[face], &tiles[face]);
+ for (auto &layer : tiles[face].layers) {
+ if (backface_culling)
+ layer.material_flags |= MATERIAL_FLAG_BACKFACE_CULLING;
+ else
+ layer.material_flags &= ~MATERIAL_FLAG_BACKFACE_CULLING;
+ layer.material_flags |= MATERIAL_FLAG_TILEABLE_HORIZONTAL;
+ layer.material_flags |= MATERIAL_FLAG_TILEABLE_VERTICAL;
+ }
+ if (!data->m_smooth_lighting) {
+ lights[face] = getFaceLight(n, neighbor, nodedef);
+ }
+ }
+ if (!faces)
+ return;
+ u8 mask = faces ^ 0b0011'1111; // k-th bit is set if k-th face is to be *omitted*, as expected by cuboid drawing functions.
+ origin = intToFloat(p, BS);
+ auto box = aabb3f(v3f(-0.5 * BS), v3f(0.5 * BS));
+ f32 texture_coord_buf[24];
+ box.MinEdge += origin;
+ box.MaxEdge += origin;
+ generateCuboidTextureCoords(box, texture_coord_buf);
+ if (data->m_smooth_lighting) {
+ LightPair lights[6][4];
+ for (int face = 0; face < 6; ++face) {
+ for (int k = 0; k < 4; k++) {
+ v3s16 corner = light_dirs[light_indices[face][k]];
+ lights[face][k] = LightPair(getSmoothLightSolid(blockpos_nodes + p, tile_dirs[face], corner, data));
+ }
+ }
+
+ drawCuboid(box, tiles, 6, texture_coord_buf, mask, [&] (int face, video::S3DVertex vertices[4]) {
+ auto final_lights = lights[face];
+ for (int j = 0; j < 4; j++) {
+ video::S3DVertex &vertex = vertices[j];
+ vertex.Color = encode_light(final_lights[j], f->light_source);
+ if (!f->light_source)
+ applyFacesShading(vertex.Color, vertex.Normal);
+ }
+ if (lightDiff(final_lights[1], final_lights[3]) < lightDiff(final_lights[0], final_lights[2]))
+ return QuadDiagonal::Diag13;
+ return QuadDiagonal::Diag02;
+ });
+ } else {
+ drawCuboid(box, tiles, 6, texture_coord_buf, mask, [&] (int face, video::S3DVertex vertices[4]) {
+ video::SColor color = encode_light(lights[face], f->light_source);
+ if (!f->light_source)
+ applyFacesShading(color, vertices[0].Normal);
+ for (int j = 0; j < 4; j++) {
+ video::S3DVertex &vertex = vertices[j];
+ vertex.Color = color;
+ }
+ return QuadDiagonal::Diag02;
+ });
}
}
void MapblockMeshGenerator::drawPlantlikeRootedNode()
{
+ drawSolidNode();
useTile(0, MATERIAL_FLAG_CRACK_OVERLAY, 0, true);
origin += v3f(0.0, BS, 0.0);
p.Y++;
void MapblockMeshGenerator::drawNode()
{
- // skip some drawtypes early
switch (f->drawtype) {
- case NDT_NORMAL: // Drawn by MapBlockMesh
case NDT_AIRLIKE: // Not drawn at all
- case NDT_LIQUID: // Drawn by MapBlockMesh
+ return;
+ case NDT_LIQUID:
+ case NDT_NORMAL: // solid nodes don’t need the usual setup
+ drawSolidNode();
return;
default:
break;
Calculate non-smooth lighting at face of node.
Single light bank.
*/
-static u8 getFaceLight(enum LightBank bank, MapNode n, MapNode n2,
- v3s16 face_dir, const NodeDefManager *ndef)
+static u8 getFaceLight(enum LightBank bank, MapNode n, MapNode n2, const NodeDefManager *ndef)
{
ContentLightingFlags f1 = ndef->getLightingFlags(n);
ContentLightingFlags f2 = ndef->getLightingFlags(n2);
Calculate non-smooth lighting at face of node.
Both light banks.
*/
-u16 getFaceLight(MapNode n, MapNode n2, const v3s16 &face_dir,
- const NodeDefManager *ndef)
+u16 getFaceLight(MapNode n, MapNode n2, const NodeDefManager *ndef)
{
- u16 day = getFaceLight(LIGHTBANK_DAY, n, n2, face_dir, ndef);
- u16 night = getFaceLight(LIGHTBANK_NIGHT, n, n2, face_dir, ndef);
+ u16 day = getFaceLight(LIGHTBANK_DAY, n, n2, ndef);
+ u16 night = getFaceLight(LIGHTBANK_NIGHT, n, n2, ndef);
return day | (night << 8);
}
v3s16(-1, 1, 1), v3s16(-1, 1,-1)
};
-/*
- vertex_dirs: v3s16[4]
-*/
-static void getNodeVertexDirs(const v3s16 &dir, v3s16 *vertex_dirs)
-{
- /*
- If looked from outside the node towards the face, the corners are:
- 0: bottom-right
- 1: bottom-left
- 2: top-left
- 3: top-right
- */
-
- // 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)
- base -= scale;
- if (dir == v3s16(0,0,1)) {
- *u = -base.X;
- *v = -base.Y;
- } else if (dir == v3s16(0,0,-1)) {
- *u = base.X + 1;
- *v = -base.Y - 1;
- } 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 - 1;
- } else if (dir == v3s16(0,-1,0)) {
- *u = base.X + 1;
- *v = base.Z + 1;
- }
-}
-
-struct FastFace
-{
- TileSpec tile;
- video::S3DVertex vertices[4]; // Precalculated vertices
- /*!
- * The face is divided into two triangles. If this is true,
- * vertices 0 and 2 are connected, othervise vertices 1 and 3
- * are connected.
- */
- bool vertex_0_2_connected;
-};
-
-static void makeFastFace(const TileSpec &tile, u16 li0, u16 li1, u16 li2, u16 li3,
- const v3f &tp, const v3f &p, const v3s16 &dir, const v3f &scale, std::vector<FastFace> &dest)
-{
- // Position is at the center of the cube.
- v3f pos = p * BS;
-
- float x0 = 0.0f;
- float y0 = 0.0f;
- float w = 1.0f;
- float h = 1.0f;
-
- v3f vertex_pos[4];
- v3s16 vertex_dirs[4];
- getNodeVertexDirs(dir, vertex_dirs);
- if (tile.world_aligned)
- getNodeTextureCoords(tp, scale, dir, &x0, &y0);
-
- v3s16 t;
- u16 t1;
- switch (tile.rotation) {
- case 0:
- break;
- case 1: //R90
- t = vertex_dirs[0];
- vertex_dirs[0] = vertex_dirs[3];
- vertex_dirs[3] = vertex_dirs[2];
- vertex_dirs[2] = vertex_dirs[1];
- vertex_dirs[1] = t;
- t1 = li0;
- li0 = li3;
- li3 = li2;
- li2 = li1;
- li1 = t1;
- break;
- case 2: //R180
- t = vertex_dirs[0];
- vertex_dirs[0] = vertex_dirs[2];
- vertex_dirs[2] = t;
- t = vertex_dirs[1];
- vertex_dirs[1] = vertex_dirs[3];
- vertex_dirs[3] = t;
- t1 = li0;
- li0 = li2;
- li2 = t1;
- t1 = li1;
- li1 = li3;
- li3 = t1;
- break;
- case 3: //R270
- t = vertex_dirs[0];
- vertex_dirs[0] = vertex_dirs[1];
- vertex_dirs[1] = vertex_dirs[2];
- vertex_dirs[2] = vertex_dirs[3];
- vertex_dirs[3] = t;
- t1 = li0;
- li0 = li1;
- li1 = li2;
- li2 = li3;
- li3 = t1;
- break;
- case 4: //FXR90
- t = vertex_dirs[0];
- vertex_dirs[0] = vertex_dirs[3];
- vertex_dirs[3] = vertex_dirs[2];
- vertex_dirs[2] = vertex_dirs[1];
- vertex_dirs[1] = t;
- t1 = li0;
- li0 = li3;
- li3 = li2;
- li2 = li1;
- li1 = t1;
- y0 += h;
- h *= -1;
- break;
- case 5: //FXR270
- t = vertex_dirs[0];
- vertex_dirs[0] = vertex_dirs[1];
- vertex_dirs[1] = vertex_dirs[2];
- vertex_dirs[2] = vertex_dirs[3];
- vertex_dirs[3] = t;
- t1 = li0;
- li0 = li1;
- li1 = li2;
- li2 = li3;
- li3 = t1;
- y0 += h;
- h *= -1;
- break;
- case 6: //FYR90
- t = vertex_dirs[0];
- vertex_dirs[0] = vertex_dirs[3];
- vertex_dirs[3] = vertex_dirs[2];
- vertex_dirs[2] = vertex_dirs[1];
- vertex_dirs[1] = t;
- t1 = li0;
- li0 = li3;
- li3 = li2;
- li2 = li1;
- li1 = t1;
- x0 += w;
- w *= -1;
- break;
- case 7: //FYR270
- t = vertex_dirs[0];
- vertex_dirs[0] = vertex_dirs[1];
- vertex_dirs[1] = vertex_dirs[2];
- vertex_dirs[2] = vertex_dirs[3];
- vertex_dirs[3] = t;
- t1 = li0;
- li0 = li1;
- li1 = li2;
- li2 = li3;
- li3 = t1;
- x0 += w;
- w *= -1;
- break;
- case 8: //FX
- y0 += h;
- h *= -1;
- break;
- case 9: //FY
- x0 += w;
- w *= -1;
- break;
- default:
- break;
- }
-
- for (u16 i = 0; i < 4; i++) {
- vertex_pos[i] = v3f(
- BS / 2 * vertex_dirs[i].X,
- BS / 2 * vertex_dirs[i].Y,
- BS / 2 * vertex_dirs[i].Z
- );
- }
-
- for (v3f &vpos : vertex_pos) {
- vpos.X *= scale.X;
- vpos.Y *= scale.Y;
- vpos.Z *= scale.Z;
- vpos += pos;
- }
-
- f32 abs_scale = 1.0f;
- if (scale.X < 0.999f || scale.X > 1.001f) abs_scale = scale.X;
- else if (scale.Y < 0.999f || scale.Y > 1.001f) abs_scale = scale.Y;
- else if (scale.Z < 0.999f || scale.Z > 1.001f) abs_scale = scale.Z;
-
- v3f normal(dir.X, dir.Y, dir.Z);
-
- u16 li[4] = { li0, li1, li2, li3 };
- u16 day[4];
- u16 night[4];
-
- for (u8 i = 0; i < 4; i++) {
- day[i] = li[i] >> 8;
- night[i] = li[i] & 0xFF;
- }
-
- bool vertex_0_2_connected = abs(day[0] - day[2]) + abs(night[0] - night[2])
- < abs(day[1] - day[3]) + abs(night[1] - night[3]);
-
- v2f32 f[4] = {
- core::vector2d<f32>(x0 + w * abs_scale, y0 + h),
- core::vector2d<f32>(x0, y0 + h),
- core::vector2d<f32>(x0, y0),
- core::vector2d<f32>(x0 + w * abs_scale, y0) };
-
- // equivalent to dest.push_back(FastFace()) but faster
- dest.emplace_back();
- FastFace& face = *dest.rbegin();
-
- for (u8 i = 0; i < 4; i++) {
- video::SColor c = encode_light(li[i], tile.emissive_light);
- if (!tile.emissive_light)
- applyFacesShading(c, normal);
-
- face.vertices[i] = video::S3DVertex(vertex_pos[i], normal, c, f[i]);
- }
-
- /*
- Revert triangles for nicer looking gradient if the
- brightness of vertices 1 and 3 differ less than
- the brightness of vertices 0 and 2.
- */
- face.vertex_0_2_connected = vertex_0_2_connected;
- face.tile = tile;
-}
-
-/*
- Nodes make a face if contents differ and solidness differs.
- Return value:
- 0: No face
- 1: Face uses m1's content
- 2: Face uses m2's content
- equivalent: Whether the blocks share the same face (eg. water and glass)
-
- TODO: Add 3: Both faces drawn with backface culling, remove equivalent
-*/
-static u8 face_contents(content_t m1, content_t m2, bool *equivalent,
- const NodeDefManager *ndef)
-{
- *equivalent = false;
-
- if (m1 == m2 || m1 == CONTENT_IGNORE || m2 == CONTENT_IGNORE)
- return 0;
-
- const ContentFeatures &f1 = ndef->get(m1);
- const ContentFeatures &f2 = ndef->get(m2);
-
- // Contents don't differ for different forms of same liquid
- if (f1.sameLiquidRender(f2))
- return 0;
-
- u8 c1 = f1.solidness;
- u8 c2 = f2.solidness;
-
- if (c1 == c2)
- return 0;
-
- if (c1 == 0)
- c1 = f1.visual_solidness;
- else if (c2 == 0)
- c2 = f2.visual_solidness;
-
- if (c1 == c2) {
- *equivalent = true;
- // If same solidness, liquid takes precense
- if (f1.isLiquidRender())
- return 1;
- if (f2.isLiquidRender())
- return 2;
- }
-
- if (c1 > c2)
- return 1;
-
- return 2;
-}
-
/*
Gets nth node tile (0 <= n <= 5).
*/
tile.rotation = tile.world_aligned ? 0 : dir_to_tile[tile_index + 1];
}
-static void getTileInfo(
- // Input:
- MeshMakeData *data,
- const v3s16 &p,
- const v3s16 &face_dir,
- // Output:
- bool &makes_face,
- v3s16 &p_corrected,
- v3s16 &face_dir_corrected,
- u16 *lights,
- u8 &waving,
- TileSpec &tile
- )
-{
- VoxelManipulator &vmanip = data->m_vmanip;
- const NodeDefManager *ndef = data->m_client->ndef();
- v3s16 blockpos_nodes = data->m_blockpos * MAP_BLOCKSIZE;
-
- const MapNode &n0 = vmanip.getNodeRefUnsafe(blockpos_nodes + p);
-
- // Don't even try to get n1 if n0 is already CONTENT_IGNORE
- if (n0.getContent() == CONTENT_IGNORE) {
- makes_face = false;
- return;
- }
-
- const MapNode &n1 = vmanip.getNodeRefUnsafeCheckFlags(blockpos_nodes + p + face_dir);
-
- if (n1.getContent() == CONTENT_IGNORE) {
- makes_face = false;
- return;
- }
-
- // This is hackish
- bool equivalent = false;
- u8 mf = face_contents(n0.getContent(), n1.getContent(),
- &equivalent, ndef);
-
- if (mf == 0) {
- makes_face = false;
- return;
- }
-
- makes_face = true;
-
- MapNode n = n0;
-
- if (mf == 1) {
- p_corrected = p;
- face_dir_corrected = face_dir;
- } else {
- n = n1;
- p_corrected = p + face_dir;
- face_dir_corrected = -face_dir;
- }
-
- 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
- if (equivalent) {
- for (TileLayer &layer : tile.layers)
- layer.material_flags |= MATERIAL_FLAG_BACKFACE_CULLING;
- }
-
- if (!data->m_smooth_lighting) {
- lights[0] = lights[1] = lights[2] = lights[3] =
- getFaceLight(n0, n1, face_dir, ndef);
- } else {
- v3s16 vertex_dirs[4];
- getNodeVertexDirs(face_dir_corrected, vertex_dirs);
-
- v3s16 light_p = blockpos_nodes + p_corrected;
- for (u16 i = 0; i < 4; i++)
- lights[i] = getSmoothLightSolid(light_p, face_dir_corrected, vertex_dirs[i], data);
- }
-}
-
-/*
- startpos:
- translate_dir: unit vector with only one of x, y or z
- face_dir: unit vector with only one of x, y or z
-*/
-static void updateFastFaceRow(
- MeshMakeData *data,
- const v3s16 &&startpos,
- v3s16 translate_dir,
- const v3f &&translate_dir_f,
- 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;
-
- bool makes_face = false;
- 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, waving, tile);
-
- // Unroll this variable which has a significant build cost
- TileSpec next_tile;
- 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;
-
- bool next_makes_face = false;
- v3s16 next_p_corrected;
- v3s16 next_face_dir_corrected;
- u16 next_lights[4] = {0, 0, 0, 0};
-
- // If at last position, there is nothing to compare to and
- // the face must be drawn anyway
- if (j != data->side_length - 1) {
- p += translate_dir;
-
- getTileInfo(data, p, face_dir,
- next_makes_face, next_p_corrected,
- next_face_dir_corrected, next_lights,
- waving,
- next_tile);
-
- 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, 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++;
- }
- }
- if (next_is_different) {
- /*
- Create a face if there should be one
- */
- if (makes_face) {
- // Floating point conversion of the position vector
- v3f pf(p_corrected.X, p_corrected.Y, p_corrected.Z);
- // Center point of face (kind of)
- v3f sp = pf - ((f32)continuous_tiles_count * 0.5f - 0.5f)
- * translate_dir_f;
- v3f scale(1, 1, 1);
-
- if (translate_dir.X != 0)
- scale.X = continuous_tiles_count;
- if (translate_dir.Y != 0)
- scale.Y = continuous_tiles_count;
- if (translate_dir.Z != 0)
- scale.Z = continuous_tiles_count;
-
- makeFastFace(tile, lights[0], lights[1], lights[2], lights[3],
- pf, sp, face_dir_corrected, scale, dest);
- 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;
- memcpy(lights, next_lights, sizeof(lights));
- if (next_is_different)
- tile = std::move(next_tile); // faster than copy
- }
-}
-
-static void updateAllFastFaceRows(MeshMakeData *data,
- std::vector<FastFace> &dest)
-{
- /*
- Go through every y,z and get top(y+) faces in rows of x+
- */
- 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
- v3f (1, 0, 0),
- v3s16(0, 1, 0), //face dir
- dest);
-
- /*
- Go through every x,y and get right(x+) faces in rows of z+
- */
- 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
- v3f (0, 0, 1),
- v3s16(1, 0, 0), //face dir
- dest);
-
- /*
- Go through every y,z and get back(z+) faces in rows of x+
- */
- 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
- v3f (1, 0, 0),
- v3s16(0, 0, 1), //face dir
- dest);
-}
-
static void applyTileColor(PreMeshBuffer &pmb)
{
video::SColor tc = pmb.layer.color;
}
}
- // 4-21ms for MAP_BLOCKSIZE=16 (NOTE: probably outdated)
- // 24-155ms for MAP_BLOCKSIZE=32 (NOTE: probably outdated)
- //TimeTaker timer1("MapBlockMesh()");
-
- std::vector<FastFace> fastfaces_new;
- fastfaces_new.reserve(512);
-
- /*
- We are including the faces of the trailing edges of the block.
- This means that when something changes, the caller must
- also update the meshes of the blocks at the leading edges.
-
- NOTE: This is the slowest part of this method.
- */
- {
- // 4-23ms for MAP_BLOCKSIZE=16 (NOTE: probably outdated)
- //TimeTaker timer2("updateAllFastFaceRows()");
- updateAllFastFaceRows(data, fastfaces_new);
- }
- // End of slow part
-
- /*
- Convert FastFaces to MeshCollector
- */
-
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)
- // (NOTE: probably outdated)
- //TimeTaker timer2("MeshCollector building");
-
- for (const FastFace &f : fastfaces_new) {
- static const u16 indices[] = {0, 1, 2, 2, 3, 0};
- static const u16 indices_alternate[] = {0, 1, 3, 2, 3, 1};
- const u16 *indices_p =
- f.vertex_0_2_connected ? indices : indices_alternate;
- collector.append(f.tile, f.vertices, 4, indices_p, 6);
- }
- }
-
/*
Add special graphics:
- torches
projects / minetest.git / commitdiff