src/client/mapblock_mesh.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "mapblock_mesh.h"
  21 #include "client.h"
  22 #include "mapblock.h"
  23 #include "map.h"
  24 #include "profiler.h"
  25 #include "shader.h"
  26 #include "mesh.h"
  27 #include "minimap.h"
  28 #include "content_mapblock.h"
  29 #include "util/directiontables.h"
  30 #include "client/meshgen/collector.h"
  31 #include "client/renderingengine.h"
  32 #include <array>
  33
  34 /*
  35         MeshMakeData
  36 */
  37
  38 MeshMakeData::MeshMakeData(Client *client, bool use_shaders,
  39                 bool use_tangent_vertices):
  40         m_client(client),
  41         m_use_shaders(use_shaders),
  42         m_use_tangent_vertices(use_tangent_vertices)
  43 {}
  44
  45 void MeshMakeData::fillBlockDataBegin(const v3s16 &blockpos)
  46 {
  47         m_blockpos = blockpos;
  48
  49         v3s16 blockpos_nodes = m_blockpos*MAP_BLOCKSIZE;
  50
  51         m_vmanip.clear();
  52         VoxelArea voxel_area(blockpos_nodes - v3s16(1,1,1) * MAP_BLOCKSIZE,
  53                         blockpos_nodes + v3s16(1,1,1) * MAP_BLOCKSIZE*2-v3s16(1,1,1));
  54         m_vmanip.addArea(voxel_area);
  55 }
  56
  57 void MeshMakeData::fillBlockData(const v3s16 &block_offset, MapNode *data)
  58 {
  59         v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
  60         VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1));
  61
  62         v3s16 bp = m_blockpos + block_offset;
  63         v3s16 blockpos_nodes = bp * MAP_BLOCKSIZE;
  64         m_vmanip.copyFrom(data, data_area, v3s16(0,0,0), blockpos_nodes, data_size);
  65 }
  66
  67 void MeshMakeData::fill(MapBlock *block)
  68 {
  69         fillBlockDataBegin(block->getPos());
  70
  71         fillBlockData(v3s16(0,0,0), block->getData());
  72
  73         // Get map for reading neighbor blocks
  74         Map *map = block->getParent();
  75
  76         for (const v3s16 &dir : g_26dirs) {
  77                 v3s16 bp = m_blockpos + dir;
  78                 MapBlock *b = map->getBlockNoCreateNoEx(bp);
  79                 if(b)
  80                         fillBlockData(dir, b->getData());
  81         }
  82 }
  83
  84 void MeshMakeData::fillSingleNode(MapNode *node)
  85 {
  86         m_blockpos = v3s16(0,0,0);
  87
  88         v3s16 blockpos_nodes = v3s16(0,0,0);
  89         VoxelArea area(blockpos_nodes-v3s16(1,1,1)*MAP_BLOCKSIZE,
  90                         blockpos_nodes+v3s16(1,1,1)*MAP_BLOCKSIZE*2-v3s16(1,1,1));
  91         s32 volume = area.getVolume();
  92         s32 our_node_index = area.index(1,1,1);
  93
  94         // Allocate this block + neighbors
  95         m_vmanip.clear();
  96         m_vmanip.addArea(area);
  97
  98         // Fill in data
  99         MapNode *data = new MapNode[volume];
 100         for(s32 i = 0; i < volume; i++)
 101         {
 102                 if (i == our_node_index)
 103                         data[i] = *node;
 104                 else
 105                         data[i] = MapNode(CONTENT_AIR, LIGHT_MAX, 0);
 106         }
 107         m_vmanip.copyFrom(data, area, area.MinEdge, area.MinEdge, area.getExtent());
 108         delete[] data;
 109 }
 110
 111 void MeshMakeData::setCrack(int crack_level, v3s16 crack_pos)
 112 {
 113         if (crack_level >= 0)
 114                 m_crack_pos_relative = crack_pos - m_blockpos*MAP_BLOCKSIZE;
 115 }
 116
 117 void MeshMakeData::setSmoothLighting(bool smooth_lighting)
 118 {
 119         m_smooth_lighting = smooth_lighting && ! g_settings->getBool("fullbright");
 120 }
 121
 122 /*
 123         Light and vertex color functions
 124 */
 125
 126 /*
 127         Calculate non-smooth lighting at interior of node.
 128         Single light bank.
 129 */
 130 static u8 getInteriorLight(enum LightBank bank, MapNode n, s32 increment,
 131         const NodeDefManager *ndef)
 132 {
 133         u8 light = n.getLight(bank, ndef);
 134         if (light > 0)
 135                 light = rangelim(light + increment, 0, LIGHT_SUN);
 136         if(g_settings->getBool("fullbright"))
 137                 return 255;
 138         return decode_light(light);
 139 }
 140
 141 /*
 142         Calculate non-smooth lighting at interior of node.
 143         Both light banks.
 144 */
 145 u16 getInteriorLight(MapNode n, s32 increment, const NodeDefManager *ndef)
 146 {
 147         u16 day = getInteriorLight(LIGHTBANK_DAY, n, increment, ndef);
 148         u16 night = getInteriorLight(LIGHTBANK_NIGHT, n, increment, ndef);
 149         return day | (night << 8);
 150 }
 151
 152 /*
 153         Calculate non-smooth lighting at face of node.
 154         Single light bank.
 155 */
 156 static u8 getFaceLight(enum LightBank bank, MapNode n, MapNode n2,
 157         v3s16 face_dir, const NodeDefManager *ndef)
 158 {
 159         u8 light;
 160         u8 l1 = n.getLight(bank, ndef);
 161         u8 l2 = n2.getLight(bank, ndef);
 162         if(l1 > l2)
 163                 light = l1;
 164         else
 165                 light = l2;
 166
 167         // Boost light level for light sources
 168         u8 light_source = MYMAX(ndef->get(n).light_source,
 169                         ndef->get(n2).light_source);
 170         if(light_source > light)
 171                 light = light_source;
 172         if(g_settings->getBool("fullbright"))
 173                 return 255;
 174         return decode_light(light);
 175 }
 176
 177 /*
 178         Calculate non-smooth lighting at face of node.
 179         Both light banks.
 180 */
 181 u16 getFaceLight(MapNode n, MapNode n2, const v3s16 &face_dir,
 182         const NodeDefManager *ndef)
 183 {
 184         u16 day = getFaceLight(LIGHTBANK_DAY, n, n2, face_dir, ndef);
 185         u16 night = getFaceLight(LIGHTBANK_NIGHT, n, n2, face_dir, ndef);
 186         return day | (night << 8);
 187 }
 188
 189 /*
 190         Calculate smooth lighting at the XYZ- corner of p.
 191         Both light banks
 192 */
 193 static u16 getSmoothLightCombined(const v3s16 &p,
 194         const std::array<v3s16,8> &dirs, MeshMakeData *data)
 195 {
 196         const NodeDefManager *ndef = data->m_client->ndef();
 197
 198         u16 ambient_occlusion = 0;
 199         u16 light_count = 0;
 200         u8 light_source_max = 0;
 201         u16 light_day = 0;
 202         u16 light_night = 0;
 203         bool direct_sunlight = false;
 204
 205         auto add_node = [&] (u8 i, bool obstructed = false) -> bool {
 206                 if (obstructed) {
 207                         ambient_occlusion++;
 208                         return false;
 209                 }
 210                 MapNode n = data->m_vmanip.getNodeNoExNoEmerge(p + dirs[i]);
 211                 if (n.getContent() == CONTENT_IGNORE)
 212                         return true;
 213                 const ContentFeatures &f = ndef->get(n);
 214                 if (f.light_source > light_source_max)
 215                         light_source_max = f.light_source;
 216                 // Check f.solidness because fast-style leaves look better this way
 217                 if (f.param_type == CPT_LIGHT && f.solidness != 2) {
 218                         u8 light_level_day = n.getLightNoChecks(LIGHTBANK_DAY, &f);
 219                         u8 light_level_night = n.getLightNoChecks(LIGHTBANK_NIGHT, &f);
 220                         if (light_level_day == LIGHT_SUN)
 221                                 direct_sunlight = true;
 222                         light_day += decode_light(light_level_day);
 223                         light_night += decode_light(light_level_night);
 224                         light_count++;
 225                 } else {
 226                         ambient_occlusion++;
 227                 }
 228                 return f.light_propagates;
 229         };
 230
 231         bool obstructed[4] = { true, true, true, true };
 232         add_node(0);
 233         bool opaque1 = !add_node(1);
 234         bool opaque2 = !add_node(2);
 235         bool opaque3 = !add_node(3);
 236         obstructed[0] = opaque1 && opaque2;
 237         obstructed[1] = opaque1 && opaque3;
 238         obstructed[2] = opaque2 && opaque3;
 239         for (u8 k = 0; k < 3; ++k)
 240                 if (add_node(k + 4, obstructed[k]))
 241                         obstructed[3] = false;
 242         if (add_node(7, obstructed[3])) { // wrap light around nodes
 243                 ambient_occlusion -= 3;
 244                 for (u8 k = 0; k < 3; ++k)
 245                         add_node(k + 4, !obstructed[k]);
 246         }
 247
 248         if (light_count == 0) {
 249                 light_day = light_night = 0;
 250         } else {
 251                 light_day /= light_count;
 252                 light_night /= light_count;
 253         }
 254
 255         // boost direct sunlight, if any
 256         if (direct_sunlight)
 257                 light_day = 0xFF;
 258
 259         // Boost brightness around light sources
 260         bool skip_ambient_occlusion_day = false;
 261         if (decode_light(light_source_max) >= light_day) {
 262                 light_day = decode_light(light_source_max);
 263                 skip_ambient_occlusion_day = true;
 264         }
 265
 266         bool skip_ambient_occlusion_night = false;
 267         if(decode_light(light_source_max) >= light_night) {
 268                 light_night = decode_light(light_source_max);
 269                 skip_ambient_occlusion_night = true;
 270         }
 271
 272         if (ambient_occlusion > 4) {
 273                 static thread_local const float ao_gamma = rangelim(
 274                         g_settings->getFloat("ambient_occlusion_gamma"), 0.25, 4.0);
 275
 276                 // Table of gamma space multiply factors.
 277                 static thread_local const float light_amount[3] = {
 278                         powf(0.75, 1.0 / ao_gamma),
 279                         powf(0.5,  1.0 / ao_gamma),
 280                         powf(0.25, 1.0 / ao_gamma)
 281                 };
 282
 283                 //calculate table index for gamma space multiplier
 284                 ambient_occlusion -= 5;
 285
 286                 if (!skip_ambient_occlusion_day)
 287                         light_day = rangelim(core::round32(
 288                                         light_day * light_amount[ambient_occlusion]), 0, 255);
 289                 if (!skip_ambient_occlusion_night)
 290                         light_night = rangelim(core::round32(
 291                                         light_night * light_amount[ambient_occlusion]), 0, 255);
 292         }
 293
 294         return light_day | (light_night << 8);
 295 }
 296
 297 /*
 298         Calculate smooth lighting at the given corner of p.
 299         Both light banks.
 300         Node at p is solid, and thus the lighting is face-dependent.
 301 */
 302 u16 getSmoothLightSolid(const v3s16 &p, const v3s16 &face_dir, const v3s16 &corner, MeshMakeData *data)
 303 {
 304         return getSmoothLightTransparent(p + face_dir, corner - 2 * face_dir, data);
 305 }
 306
 307 /*
 308         Calculate smooth lighting at the given corner of p.
 309         Both light banks.
 310         Node at p is not solid, and the lighting is not face-dependent.
 311 */
 312 u16 getSmoothLightTransparent(const v3s16 &p, const v3s16 &corner, MeshMakeData *data)
 313 {
 314         const std::array<v3s16,8> dirs = {{
 315                 // Always shine light
 316                 v3s16(0,0,0),
 317                 v3s16(corner.X,0,0),
 318                 v3s16(0,corner.Y,0),
 319                 v3s16(0,0,corner.Z),
 320
 321                 // Can be obstructed
 322                 v3s16(corner.X,corner.Y,0),
 323                 v3s16(corner.X,0,corner.Z),
 324                 v3s16(0,corner.Y,corner.Z),
 325                 v3s16(corner.X,corner.Y,corner.Z)
 326         }};
 327         return getSmoothLightCombined(p, dirs, data);
 328 }
 329
 330 void get_sunlight_color(video::SColorf *sunlight, u32 daynight_ratio){
 331         f32 rg = daynight_ratio / 1000.0f - 0.04f;
 332         f32 b = (0.98f * daynight_ratio) / 1000.0f + 0.078f;
 333         sunlight->r = rg;
 334         sunlight->g = rg;
 335         sunlight->b = b;
 336 }
 337
 338 void final_color_blend(video::SColor *result,
 339                 u16 light, u32 daynight_ratio)
 340 {
 341         video::SColorf dayLight;
 342         get_sunlight_color(&dayLight, daynight_ratio);
 343         final_color_blend(result,
 344                 encode_light(light, 0), dayLight);
 345 }
 346
 347 void final_color_blend(video::SColor *result,
 348                 const video::SColor &data, const video::SColorf &dayLight)
 349 {
 350         static const video::SColorf artificialColor(1.04f, 1.04f, 1.04f);
 351
 352         video::SColorf c(data);
 353         f32 n = 1 - c.a;
 354
 355         f32 r = c.r * (c.a * dayLight.r + n * artificialColor.r) * 2.0f;
 356         f32 g = c.g * (c.a * dayLight.g + n * artificialColor.g) * 2.0f;
 357         f32 b = c.b * (c.a * dayLight.b + n * artificialColor.b) * 2.0f;
 358
 359         // Emphase blue a bit in darker places
 360         // Each entry of this array represents a range of 8 blue levels
 361         static const u8 emphase_blue_when_dark[32] = {
 362                 1, 4, 6, 6, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0,
 363                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 364         };
 365
 366         b += emphase_blue_when_dark[irr::core::clamp((s32) ((r + g + b) / 3 * 255),
 367                 0, 255) / 8] / 255.0f;
 368
 369         result->setRed(core::clamp((s32) (r * 255.0f), 0, 255));
 370         result->setGreen(core::clamp((s32) (g * 255.0f), 0, 255));
 371         result->setBlue(core::clamp((s32) (b * 255.0f), 0, 255));
 372 }
 373
 374 /*
 375         Mesh generation helpers
 376 */
 377
 378 // This table is moved outside getNodeVertexDirs to avoid the compiler using
 379 // a mutex to initialize this table at runtime right in the hot path.
 380 // For details search the internet for "cxa_guard_acquire".
 381 static const v3s16 vertex_dirs_table[] = {
 382         // ( 1, 0, 0)
 383         v3s16( 1,-1, 1), v3s16( 1,-1,-1),
 384         v3s16( 1, 1,-1), v3s16( 1, 1, 1),
 385         // ( 0, 1, 0)
 386         v3s16( 1, 1,-1), v3s16(-1, 1,-1),
 387         v3s16(-1, 1, 1), v3s16( 1, 1, 1),
 388         // ( 0, 0, 1)
 389         v3s16(-1,-1, 1), v3s16( 1,-1, 1),
 390         v3s16( 1, 1, 1), v3s16(-1, 1, 1),
 391         // invalid
 392         v3s16(), v3s16(), v3s16(), v3s16(),
 393         // ( 0, 0,-1)
 394         v3s16( 1,-1,-1), v3s16(-1,-1,-1),
 395         v3s16(-1, 1,-1), v3s16( 1, 1,-1),
 396         // ( 0,-1, 0)
 397         v3s16( 1,-1, 1), v3s16(-1,-1, 1),
 398         v3s16(-1,-1,-1), v3s16( 1,-1,-1),
 399         // (-1, 0, 0)
 400         v3s16(-1,-1,-1), v3s16(-1,-1, 1),
 401         v3s16(-1, 1, 1), v3s16(-1, 1,-1)
 402 };
 403
 404 /*
 405         vertex_dirs: v3s16[4]
 406 */
 407 static void getNodeVertexDirs(const v3s16 &dir, v3s16 *vertex_dirs)
 408 {
 409         /*
 410                 If looked from outside the node towards the face, the corners are:
 411                 0: bottom-right
 412                 1: bottom-left
 413                 2: top-left
 414                 3: top-right
 415         */
 416
 417         // Direction must be (1,0,0), (-1,0,0), (0,1,0), (0,-1,0),
 418         // (0,0,1), (0,0,-1)
 419         assert(dir.X * dir.X + dir.Y * dir.Y + dir.Z * dir.Z == 1);
 420
 421         // Convert direction to single integer for table lookup
 422         u8 idx = (dir.X + 2 * dir.Y + 3 * dir.Z) & 7;
 423         idx = (idx - 1) * 4;
 424
 425         memcpy(vertex_dirs, &vertex_dirs_table[idx], 4 * sizeof(v3s16));
 426 }
 427
 428 static void getNodeTextureCoords(v3f base, const v3f &scale, const v3s16 &dir, float *u, float *v)
 429 {
 430         if (dir.X > 0 || dir.Y > 0 || dir.Z < 0)
 431                 base -= scale;
 432         if (dir == v3s16(0,0,1)) {
 433                 *u = -base.X - 1;
 434                 *v = -base.Y - 1;
 435         } else if (dir == v3s16(0,0,-1)) {
 436                 *u = base.X + 1;
 437                 *v = -base.Y - 2;
 438         } else if (dir == v3s16(1,0,0)) {
 439                 *u = base.Z + 1;
 440                 *v = -base.Y - 2;
 441         } else if (dir == v3s16(-1,0,0)) {
 442                 *u = -base.Z - 1;
 443                 *v = -base.Y - 1;
 444         } else if (dir == v3s16(0,1,0)) {
 445                 *u = base.X + 1;
 446                 *v = -base.Z - 2;
 447         } else if (dir == v3s16(0,-1,0)) {
 448                 *u = base.X;
 449                 *v = base.Z;
 450         }
 451 }
 452
 453 struct FastFace
 454 {
 455         TileSpec tile;
 456         video::S3DVertex vertices[4]; // Precalculated vertices
 457         /*!
 458          * The face is divided into two triangles. If this is true,
 459          * vertices 0 and 2 are connected, othervise vertices 1 and 3
 460          * are connected.
 461          */
 462         bool vertex_0_2_connected;
 463 };
 464
 465 static void makeFastFace(const TileSpec &tile, u16 li0, u16 li1, u16 li2, u16 li3,
 466         const v3f &tp, const v3f &p, const v3s16 &dir, const v3f &scale, std::vector<FastFace> &dest)
 467 {
 468         // Position is at the center of the cube.
 469         v3f pos = p * BS;
 470
 471         float x0 = 0.0f;
 472         float y0 = 0.0f;
 473         float w = 1.0f;
 474         float h = 1.0f;
 475
 476         v3f vertex_pos[4];
 477         v3s16 vertex_dirs[4];
 478         getNodeVertexDirs(dir, vertex_dirs);
 479         if (tile.world_aligned)
 480                 getNodeTextureCoords(tp, scale, dir, &x0, &y0);
 481
 482         v3s16 t;
 483         u16 t1;
 484         switch (tile.rotation) {
 485         case 0:
 486                 break;
 487         case 1: //R90
 488                 t = vertex_dirs[0];
 489                 vertex_dirs[0] = vertex_dirs[3];
 490                 vertex_dirs[3] = vertex_dirs[2];
 491                 vertex_dirs[2] = vertex_dirs[1];
 492                 vertex_dirs[1] = t;
 493                 t1  = li0;
 494                 li0 = li3;
 495                 li3 = li2;
 496                 li2 = li1;
 497                 li1 = t1;
 498                 break;
 499         case 2: //R180
 500                 t = vertex_dirs[0];
 501                 vertex_dirs[0] = vertex_dirs[2];
 502                 vertex_dirs[2] = t;
 503                 t = vertex_dirs[1];
 504                 vertex_dirs[1] = vertex_dirs[3];
 505                 vertex_dirs[3] = t;
 506                 t1  = li0;
 507                 li0 = li2;
 508                 li2 = t1;
 509                 t1  = li1;
 510                 li1 = li3;
 511                 li3 = t1;
 512                 break;
 513         case 3: //R270
 514                 t = vertex_dirs[0];
 515                 vertex_dirs[0] = vertex_dirs[1];
 516                 vertex_dirs[1] = vertex_dirs[2];
 517                 vertex_dirs[2] = vertex_dirs[3];
 518                 vertex_dirs[3] = t;
 519                 t1  = li0;
 520                 li0 = li1;
 521                 li1 = li2;
 522                 li2 = li3;
 523                 li3 = t1;
 524                 break;
 525         case 4: //FXR90
 526                 t = vertex_dirs[0];
 527                 vertex_dirs[0] = vertex_dirs[3];
 528                 vertex_dirs[3] = vertex_dirs[2];
 529                 vertex_dirs[2] = vertex_dirs[1];
 530                 vertex_dirs[1] = t;
 531                 t1  = li0;
 532                 li0 = li3;
 533                 li3 = li2;
 534                 li2 = li1;
 535                 li1 = t1;
 536                 y0 += h;
 537                 h *= -1;
 538                 break;
 539         case 5: //FXR270
 540                 t = vertex_dirs[0];
 541                 vertex_dirs[0] = vertex_dirs[1];
 542                 vertex_dirs[1] = vertex_dirs[2];
 543                 vertex_dirs[2] = vertex_dirs[3];
 544                 vertex_dirs[3] = t;
 545                 t1  = li0;
 546                 li0 = li1;
 547                 li1 = li2;
 548                 li2 = li3;
 549                 li3 = t1;
 550                 y0 += h;
 551                 h *= -1;
 552                 break;
 553         case 6: //FYR90
 554                 t = vertex_dirs[0];
 555                 vertex_dirs[0] = vertex_dirs[3];
 556                 vertex_dirs[3] = vertex_dirs[2];
 557                 vertex_dirs[2] = vertex_dirs[1];
 558                 vertex_dirs[1] = t;
 559                 t1  = li0;
 560                 li0 = li3;
 561                 li3 = li2;
 562                 li2 = li1;
 563                 li1 = t1;
 564                 x0 += w;
 565                 w *= -1;
 566                 break;
 567         case 7: //FYR270
 568                 t = vertex_dirs[0];
 569                 vertex_dirs[0] = vertex_dirs[1];
 570                 vertex_dirs[1] = vertex_dirs[2];
 571                 vertex_dirs[2] = vertex_dirs[3];
 572                 vertex_dirs[3] = t;
 573                 t1  = li0;
 574                 li0 = li1;
 575                 li1 = li2;
 576                 li2 = li3;
 577                 li3 = t1;
 578                 x0 += w;
 579                 w *= -1;
 580                 break;
 581         case 8: //FX
 582                 y0 += h;
 583                 h *= -1;
 584                 break;
 585         case 9: //FY
 586                 x0 += w;
 587                 w *= -1;
 588                 break;
 589         default:
 590                 break;
 591         }
 592
 593         for (u16 i = 0; i < 4; i++) {
 594                 vertex_pos[i] = v3f(
 595                                 BS / 2 * vertex_dirs[i].X,
 596                                 BS / 2 * vertex_dirs[i].Y,
 597                                 BS / 2 * vertex_dirs[i].Z
 598                 );
 599         }
 600
 601         for (v3f &vpos : vertex_pos) {
 602                 vpos.X *= scale.X;
 603                 vpos.Y *= scale.Y;
 604                 vpos.Z *= scale.Z;
 605                 vpos += pos;
 606         }
 607
 608         f32 abs_scale = 1.0f;
 609         if      (scale.X < 0.999f || scale.X > 1.001f) abs_scale = scale.X;
 610         else if (scale.Y < 0.999f || scale.Y > 1.001f) abs_scale = scale.Y;
 611         else if (scale.Z < 0.999f || scale.Z > 1.001f) abs_scale = scale.Z;
 612
 613         v3f normal(dir.X, dir.Y, dir.Z);
 614
 615         u16 li[4] = { li0, li1, li2, li3 };
 616         u16 day[4];
 617         u16 night[4];
 618
 619         for (u8 i = 0; i < 4; i++) {
 620                 day[i] = li[i] >> 8;
 621                 night[i] = li[i] & 0xFF;
 622         }
 623
 624         bool vertex_0_2_connected = abs(day[0] - day[2]) + abs(night[0] - night[2])
 625                         < abs(day[1] - day[3]) + abs(night[1] - night[3]);
 626
 627         v2f32 f[4] = {
 628                 core::vector2d<f32>(x0 + w * abs_scale, y0 + h),
 629                 core::vector2d<f32>(x0, y0 + h),
 630                 core::vector2d<f32>(x0, y0),
 631                 core::vector2d<f32>(x0 + w * abs_scale, y0) };
 632
 633         // equivalent to dest.push_back(FastFace()) but faster
 634         dest.emplace_back();
 635         FastFace& face = *dest.rbegin();
 636
 637         for (u8 i = 0; i < 4; i++) {
 638                 video::SColor c = encode_light(li[i], tile.emissive_light);
 639                 if (!tile.emissive_light)
 640                         applyFacesShading(c, normal);
 641
 642                 face.vertices[i] = video::S3DVertex(vertex_pos[i], normal, c, f[i]);
 643         }
 644
 645         /*
 646                 Revert triangles for nicer looking gradient if the
 647                 brightness of vertices 1 and 3 differ less than
 648                 the brightness of vertices 0 and 2.
 649                 */
 650         face.vertex_0_2_connected = vertex_0_2_connected;
 651         face.tile = tile;
 652 }
 653
 654 /*
 655         Nodes make a face if contents differ and solidness differs.
 656         Return value:
 657                 0: No face
 658                 1: Face uses m1's content
 659                 2: Face uses m2's content
 660         equivalent: Whether the blocks share the same face (eg. water and glass)
 661
 662         TODO: Add 3: Both faces drawn with backface culling, remove equivalent
 663 */
 664 static u8 face_contents(content_t m1, content_t m2, bool *equivalent,
 665         const NodeDefManager *ndef)
 666 {
 667         *equivalent = false;
 668
 669         if (m1 == m2 || m1 == CONTENT_IGNORE || m2 == CONTENT_IGNORE)
 670                 return 0;
 671
 672         const ContentFeatures &f1 = ndef->get(m1);
 673         const ContentFeatures &f2 = ndef->get(m2);
 674
 675         // Contents don't differ for different forms of same liquid
 676         if (f1.sameLiquid(f2))
 677                 return 0;
 678
 679         u8 c1 = f1.solidness;
 680         u8 c2 = f2.solidness;
 681
 682
 683         if (c1 == c2)
 684                 return 0;
 685
 686         if (c1 == 0)
 687                 c1 = f1.visual_solidness;
 688         else if (c2 == 0)
 689                 c2 = f2.visual_solidness;
 690
 691
 692         if (c1 == c2) {
 693                 *equivalent = true;
 694                 // If same solidness, liquid takes precense
 695                 if (f1.isLiquid())
 696                         return 1;
 697                 if (f2.isLiquid())
 698                         return 2;
 699         }
 700
 701         if (c1 > c2)
 702                 return 1;
 703
 704         return 2;
 705 }
 706
 707 /*
 708         Gets nth node tile (0 <= n <= 5).
 709 */
 710 void getNodeTileN(MapNode mn, const v3s16 &p, u8 tileindex, MeshMakeData *data, TileSpec &tile)
 711 {
 712         const NodeDefManager *ndef = data->m_client->ndef();
 713         const ContentFeatures &f = ndef->get(mn);
 714         tile = f.tiles[tileindex];
 715         bool has_crack = p == data->m_crack_pos_relative;
 716         for (TileLayer &layer : tile.layers) {
 717                 if (layer.texture_id == 0)
 718                         continue;
 719                 if (!layer.has_color)
 720                         mn.getColor(f, &(layer.color));
 721                 // Apply temporary crack
 722                 if (has_crack)
 723                         layer.material_flags |= MATERIAL_FLAG_CRACK;
 724         }
 725 }
 726
 727 /*
 728         Gets node tile given a face direction.
 729 */
 730 void getNodeTile(MapNode mn, const v3s16 &p, const v3s16 &dir, MeshMakeData *data, TileSpec &tile)
 731 {
 732         const NodeDefManager *ndef = data->m_client->ndef();
 733
 734         // Direction must be (1,0,0), (-1,0,0), (0,1,0), (0,-1,0),
 735         // (0,0,1), (0,0,-1) or (0,0,0)
 736         assert(dir.X * dir.X + dir.Y * dir.Y + dir.Z * dir.Z <= 1);
 737
 738         // Convert direction to single integer for table lookup
 739         //  0 = (0,0,0)
 740         //  1 = (1,0,0)
 741         //  2 = (0,1,0)
 742         //  3 = (0,0,1)
 743         //  4 = invalid, treat as (0,0,0)
 744         //  5 = (0,0,-1)
 745         //  6 = (0,-1,0)
 746         //  7 = (-1,0,0)
 747         u8 dir_i = ((dir.X + 2 * dir.Y + 3 * dir.Z) & 7) * 2;
 748
 749         // Get rotation for things like chests
 750         u8 facedir = mn.getFaceDir(ndef, true);
 751
 752         static const u16 dir_to_tile[24 * 16] =
 753         {
 754                 // 0     +X    +Y    +Z           -Z    -Y    -X   ->   value=tile,rotation
 755                    0,0,  2,0 , 0,0 , 4,0 ,  0,0,  5,0 , 1,0 , 3,0 ,  // rotate around y+ 0 - 3
 756                    0,0,  4,0 , 0,3 , 3,0 ,  0,0,  2,0 , 1,1 , 5,0 ,
 757                    0,0,  3,0 , 0,2 , 5,0 ,  0,0,  4,0 , 1,2 , 2,0 ,
 758                    0,0,  5,0 , 0,1 , 2,0 ,  0,0,  3,0 , 1,3 , 4,0 ,
 759
 760                    0,0,  2,3 , 5,0 , 0,2 ,  0,0,  1,0 , 4,2 , 3,1 ,  // rotate around z+ 4 - 7
 761                    0,0,  4,3 , 2,0 , 0,1 ,  0,0,  1,1 , 3,2 , 5,1 ,
 762                    0,0,  3,3 , 4,0 , 0,0 ,  0,0,  1,2 , 5,2 , 2,1 ,
 763                    0,0,  5,3 , 3,0 , 0,3 ,  0,0,  1,3 , 2,2 , 4,1 ,
 764
 765                    0,0,  2,1 , 4,2 , 1,2 ,  0,0,  0,0 , 5,0 , 3,3 ,  // rotate around z- 8 - 11
 766                    0,0,  4,1 , 3,2 , 1,3 ,  0,0,  0,3 , 2,0 , 5,3 ,
 767                    0,0,  3,1 , 5,2 , 1,0 ,  0,0,  0,2 , 4,0 , 2,3 ,
 768                    0,0,  5,1 , 2,2 , 1,1 ,  0,0,  0,1 , 3,0 , 4,3 ,
 769
 770                    0,0,  0,3 , 3,3 , 4,1 ,  0,0,  5,3 , 2,3 , 1,3 ,  // rotate around x+ 12 - 15
 771                    0,0,  0,2 , 5,3 , 3,1 ,  0,0,  2,3 , 4,3 , 1,0 ,
 772                    0,0,  0,1 , 2,3 , 5,1 ,  0,0,  4,3 , 3,3 , 1,1 ,
 773                    0,0,  0,0 , 4,3 , 2,1 ,  0,0,  3,3 , 5,3 , 1,2 ,
 774
 775                    0,0,  1,1 , 2,1 , 4,3 ,  0,0,  5,1 , 3,1 , 0,1 ,  // rotate around x- 16 - 19
 776                    0,0,  1,2 , 4,1 , 3,3 ,  0,0,  2,1 , 5,1 , 0,0 ,
 777                    0,0,  1,3 , 3,1 , 5,3 ,  0,0,  4,1 , 2,1 , 0,3 ,
 778                    0,0,  1,0 , 5,1 , 2,3 ,  0,0,  3,1 , 4,1 , 0,2 ,
 779
 780                    0,0,  3,2 , 1,2 , 4,2 ,  0,0,  5,2 , 0,2 , 2,2 ,  // rotate around y- 20 - 23
 781                    0,0,  5,2 , 1,3 , 3,2 ,  0,0,  2,2 , 0,1 , 4,2 ,
 782                    0,0,  2,2 , 1,0 , 5,2 ,  0,0,  4,2 , 0,0 , 3,2 ,
 783                    0,0,  4,2 , 1,1 , 2,2 ,  0,0,  3,2 , 0,3 , 5,2
 784
 785         };
 786         u16 tile_index = facedir * 16 + dir_i;
 787         getNodeTileN(mn, p, dir_to_tile[tile_index], data, tile);
 788         tile.rotation = tile.world_aligned ? 0 : dir_to_tile[tile_index + 1];
 789 }
 790
 791 std::set<content_t> splitToContentT(std::string str, const NodeDefManager *ndef)
 792 {
 793         str += "\n";
 794         std::set<content_t> dat;
 795         std::string buf;
 796         for (char c : str) {
 797                 if (c == ',' || c == '\n') {
 798                         if (! buf.empty()) {
 799                                 dat.insert(ndef->getId(buf));
 800                         }
 801                         buf.clear();
 802                 } else if (c != ' ') {
 803                         buf += c;
 804                 }
 805         }
 806         return dat;
 807 }
 808
 809 static void getTileInfo(
 810                 // Input:
 811                 MeshMakeData *data,
 812                 const v3s16 &p,
 813                 const v3s16 &face_dir,
 814                 // Output:
 815                 bool &makes_face,
 816                 v3s16 &p_corrected,
 817                 v3s16 &face_dir_corrected,
 818                 u16 *lights,
 819                 u8 &waving,
 820                 TileSpec &tile,
 821                 // lol more Input
 822                 bool xray,
 823                 std::set<content_t> xraySet,
 824                 std::set<content_t> nodeESPSet)
 825 {
 826         VoxelManipulator &vmanip = data->m_vmanip;
 827         const NodeDefManager *ndef = data->m_client->ndef();
 828         v3s16 blockpos_nodes = data->m_blockpos * MAP_BLOCKSIZE;
 829
 830         const MapNode &n0 = vmanip.getNodeRefUnsafe(blockpos_nodes + p);
 831
 832         content_t c0 = n0.getContent();
 833         if (xray && xraySet.find(c0) != xraySet.end())
 834                 c0 = CONTENT_AIR;
 835         if (nodeESPSet.find(c0) != nodeESPSet.end())
 836                 data->m_esp_nodes.insert(blockpos_nodes + p);
 837         // Don't even try to get n1 if n0 is already CONTENT_IGNORE
 838         if (c0 == CONTENT_IGNORE) {
 839                 makes_face = false;
 840                 return;
 841         }
 842
 843         const MapNode &n1 = vmanip.getNodeRefUnsafeCheckFlags(blockpos_nodes + p + face_dir);
 844
 845         content_t c1 = n1.getContent();
 846         if (xray && xraySet.find(c1) != xraySet.end())
 847                 c1 = CONTENT_AIR;
 848
 849         if (c1 == CONTENT_IGNORE) {
 850                 makes_face = false;
 851                 return;
 852         }
 853
 854         // This is hackish
 855         bool equivalent = false;
 856         u8 mf = face_contents(c0, c1,
 857                         &equivalent, ndef);
 858
 859         if (mf == 0) {
 860                 makes_face = false;
 861                 return;
 862         }
 863
 864         makes_face = true;
 865
 866         MapNode n = n0;
 867
 868         if (mf == 1) {
 869                 p_corrected = p;
 870                 face_dir_corrected = face_dir;
 871         } else {
 872                 n = n1;
 873                 p_corrected = p + face_dir;
 874                 face_dir_corrected = -face_dir;
 875         }
 876
 877         getNodeTile(n, p_corrected, face_dir_corrected, data, tile);
 878         const ContentFeatures &f = ndef->get(n);
 879         waving = f.waving;
 880         tile.emissive_light = f.light_source;
 881
 882         // eg. water and glass
 883         if (equivalent) {
 884                 for (TileLayer &layer : tile.layers)
 885                         layer.material_flags |= MATERIAL_FLAG_BACKFACE_CULLING;
 886         }
 887
 888         if (!data->m_smooth_lighting) {
 889                 lights[0] = lights[1] = lights[2] = lights[3] =
 890                                 getFaceLight(n0, n1, face_dir, ndef);
 891         } else {
 892                 v3s16 vertex_dirs[4];
 893                 getNodeVertexDirs(face_dir_corrected, vertex_dirs);
 894
 895                 v3s16 light_p = blockpos_nodes + p_corrected;
 896                 for (u16 i = 0; i < 4; i++)
 897                         lights[i] = getSmoothLightSolid(light_p, face_dir_corrected, vertex_dirs[i], data);
 898         }
 899 }
 900
 901 /*
 902         startpos:
 903         translate_dir: unit vector with only one of x, y or z
 904         face_dir: unit vector with only one of x, y or z
 905 */
 906 static void updateFastFaceRow(
 907                 MeshMakeData *data,
 908                 const v3s16 &&startpos,
 909                 v3s16 translate_dir,
 910                 const v3f &&translate_dir_f,
 911                 const v3s16 &&face_dir,
 912                 std::vector<FastFace> &dest,
 913                 bool xray,
 914                 std::set<content_t> xraySet,
 915                 std::set<content_t> nodeESPSet)
 916 {
 917         static thread_local const bool waving_liquids =
 918                 g_settings->getBool("enable_shaders") &&
 919                 g_settings->getBool("enable_waving_water");
 920
 921         v3s16 p = startpos;
 922
 923         u16 continuous_tiles_count = 1;
 924
 925         bool makes_face = false;
 926         v3s16 p_corrected;
 927         v3s16 face_dir_corrected;
 928         u16 lights[4] = {0, 0, 0, 0};
 929         u8 waving = 0;
 930         TileSpec tile;
 931
 932         // Get info of first tile
 933         getTileInfo(data, p, face_dir,
 934                         makes_face, p_corrected, face_dir_corrected,
 935                         lights, waving, tile, xray, xraySet, nodeESPSet);
 936
 937         // Unroll this variable which has a significant build cost
 938         TileSpec next_tile;
 939         for (u16 j = 0; j < MAP_BLOCKSIZE; j++) {
 940                 // If tiling can be done, this is set to false in the next step
 941                 bool next_is_different = true;
 942
 943                 bool next_makes_face = false;
 944                 v3s16 next_p_corrected;
 945                 v3s16 next_face_dir_corrected;
 946                 u16 next_lights[4] = {0, 0, 0, 0};
 947
 948                 // If at last position, there is nothing to compare to and
 949                 // the face must be drawn anyway
 950                 if (j != MAP_BLOCKSIZE - 1) {
 951                         p += translate_dir;
 952
 953                         getTileInfo(data, p, face_dir,
 954                                         next_makes_face, next_p_corrected,
 955                                         next_face_dir_corrected, next_lights,
 956                                         waving,
 957                                         next_tile,
 958                                         xray,
 959                                         xraySet,
 960                                         nodeESPSet);
 961
 962                         if (next_makes_face == makes_face
 963                                         && next_p_corrected == p_corrected + translate_dir
 964                                         && next_face_dir_corrected == face_dir_corrected
 965                                         && memcmp(next_lights, lights, sizeof(lights)) == 0
 966                                         // Don't apply fast faces to waving water.
 967                                         && (waving != 3 || !waving_liquids)
 968                                         && next_tile.isTileable(tile)) {
 969                                 next_is_different = false;
 970                                 continuous_tiles_count++;
 971                         }
 972                 }
 973                 if (next_is_different) {
 974                         /*
 975                                 Create a face if there should be one
 976                         */
 977                         if (makes_face) {
 978                                 // Floating point conversion of the position vector
 979                                 v3f pf(p_corrected.X, p_corrected.Y, p_corrected.Z);
 980                                 // Center point of face (kind of)
 981                                 v3f sp = pf - ((f32)continuous_tiles_count * 0.5f - 0.5f)
 982                                         * translate_dir_f;
 983                                 v3f scale(1, 1, 1);
 984
 985                                 if (translate_dir.X != 0)
 986                                         scale.X = continuous_tiles_count;
 987                                 if (translate_dir.Y != 0)
 988                                         scale.Y = continuous_tiles_count;
 989                                 if (translate_dir.Z != 0)
 990                                         scale.Z = continuous_tiles_count;
 991
 992                                 makeFastFace(tile, lights[0], lights[1], lights[2], lights[3],
 993                                                 pf, sp, face_dir_corrected, scale, dest);
 994                                 g_profiler->avg("Meshgen: Tiles per face [#]", continuous_tiles_count);
 995                         }
 996
 997                         continuous_tiles_count = 1;
 998                 }
 999
1000                 makes_face = next_makes_face;
1001                 p_corrected = next_p_corrected;
1002                 face_dir_corrected = next_face_dir_corrected;
1003                 memcpy(lights, next_lights, sizeof(lights));
1004                 if (next_is_different)
1005                         tile = std::move(next_tile); // faster than copy
1006         }
1007 }
1008
1009 static void updateAllFastFaceRows(MeshMakeData *data,
1010                 std::vector<FastFace> &dest, bool xray, std::set<content_t> xraySet, std::set<content_t> nodeESPSet)
1011 {
1012         /*
1013                 Go through every y,z and get top(y+) faces in rows of x+
1014         */
1015         for (s16 y = 0; y < MAP_BLOCKSIZE; y++)
1016         for (s16 z = 0; z < MAP_BLOCKSIZE; z++)
1017                 updateFastFaceRow(data,
1018                                 v3s16(0, y, z),
1019                                 v3s16(1, 0, 0), //dir
1020                                 v3f  (1, 0, 0),
1021                                 v3s16(0, 1, 0), //face dir
1022                                 dest,
1023                                 xray,
1024                                 xraySet,
1025                                 nodeESPSet);
1026
1027         /*
1028                 Go through every x,y and get right(x+) faces in rows of z+
1029         */
1030         for (s16 x = 0; x < MAP_BLOCKSIZE; x++)
1031         for (s16 y = 0; y < MAP_BLOCKSIZE; y++)
1032                 updateFastFaceRow(data,
1033                                 v3s16(x, y, 0),
1034                                 v3s16(0, 0, 1), //dir
1035                                 v3f  (0, 0, 1),
1036                                 v3s16(1, 0, 0), //face dir
1037                                 dest,
1038                                 xray,
1039                                 xraySet,
1040                                 nodeESPSet);
1041
1042         /*
1043                 Go through every y,z and get back(z+) faces in rows of x+
1044         */
1045         for (s16 z = 0; z < MAP_BLOCKSIZE; z++)
1046         for (s16 y = 0; y < MAP_BLOCKSIZE; y++)
1047                 updateFastFaceRow(data,
1048                                 v3s16(0, y, z),
1049                                 v3s16(1, 0, 0), //dir
1050                                 v3f  (1, 0, 0),
1051                                 v3s16(0, 0, 1), //face dir
1052                                 dest,
1053                                 xray,
1054                                 xraySet,
1055                                 nodeESPSet);
1056 }
1057
1058 static void applyTileColor(PreMeshBuffer &pmb)
1059 {
1060         video::SColor tc = pmb.layer.color;
1061         if (tc == video::SColor(0xFFFFFFFF))
1062                 return;
1063         for (video::S3DVertex &vertex : pmb.vertices) {
1064                 video::SColor *c = &vertex.Color;
1065                 c->set(c->getAlpha(),
1066                         c->getRed() * tc.getRed() / 255,
1067                         c->getGreen() * tc.getGreen() / 255,
1068                         c->getBlue() * tc.getBlue() / 255);
1069         }
1070 }
1071
1072 /*
1073         MapBlockMesh
1074 */
1075
1076 MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset):
1077         m_minimap_mapblock(NULL),
1078         m_tsrc(data->m_client->getTextureSource()),
1079         m_shdrsrc(data->m_client->getShaderSource()),
1080         m_animation_force_timer(0), // force initial animation
1081         m_last_crack(-1),
1082         m_last_daynight_ratio((u32) -1)
1083 {
1084         for (auto &m : m_mesh)
1085                 m = new scene::SMesh();
1086         m_enable_shaders = data->m_use_shaders;
1087         m_use_tangent_vertices = data->m_use_tangent_vertices;
1088         m_enable_vbo = g_settings->getBool("enable_vbo");
1089
1090         if (g_settings->getBool("enable_minimap")) {
1091                 m_minimap_mapblock = new MinimapMapblock;
1092                 m_minimap_mapblock->getMinimapNodes(
1093                         &data->m_vmanip, data->m_blockpos * MAP_BLOCKSIZE);
1094         }
1095
1096         // 4-21ms for MAP_BLOCKSIZE=16  (NOTE: probably outdated)
1097         // 24-155ms for MAP_BLOCKSIZE=32  (NOTE: probably outdated)
1098         //TimeTaker timer1("MapBlockMesh()");
1099
1100         std::vector<FastFace> fastfaces_new;
1101         fastfaces_new.reserve(512);
1102         /*
1103                 X-Ray
1104         */
1105         bool xray = g_settings->getBool("xray");
1106         std::set<content_t> xraySet, nodeESPSet;
1107         if (xray)
1108                 xraySet = splitToContentT(g_settings->get("xray_nodes"), data->m_client->ndef());
1109
1110         nodeESPSet = splitToContentT(g_settings->get("node_esp_nodes"), data->m_client->ndef());
1111
1112         /*
1113                 We are including the faces of the trailing edges of the block.
1114                 This means that when something changes, the caller must
1115                 also update the meshes of the blocks at the leading edges.
1116
1117                 NOTE: This is the slowest part of this method.
1118         */
1119         {
1120                 // 4-23ms for MAP_BLOCKSIZE=16  (NOTE: probably outdated)
1121                 //TimeTaker timer2("updateAllFastFaceRows()");
1122                 updateAllFastFaceRows(data, fastfaces_new, xray, xraySet, nodeESPSet);
1123         }
1124         // End of slow part
1125
1126         /*
1127                 Convert FastFaces to MeshCollector
1128         */
1129
1130         MeshCollector collector;
1131
1132         {
1133                 // avg 0ms (100ms spikes when loading textures the first time)
1134                 // (NOTE: probably outdated)
1135                 //TimeTaker timer2("MeshCollector building");
1136
1137                 for (const FastFace &f : fastfaces_new) {
1138                         static const u16 indices[] = {0, 1, 2, 2, 3, 0};
1139                         static const u16 indices_alternate[] = {0, 1, 3, 2, 3, 1};
1140                         const u16 *indices_p =
1141                                 f.vertex_0_2_connected ? indices : indices_alternate;
1142                         collector.append(f.tile, f.vertices, 4, indices_p, 6);
1143                 }
1144         }
1145
1146         /*
1147                 Add special graphics:
1148                 - torches
1149                 - flowing water
1150                 - fences
1151                 - whatever
1152         */
1153
1154         {
1155                 MapblockMeshGenerator generator(data, &collector);
1156                 generator.generate();
1157         }
1158
1159         /*
1160                 Convert MeshCollector to SMesh
1161         */
1162
1163         for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
1164                 for(u32 i = 0; i < collector.prebuffers[layer].size(); i++)
1165                 {
1166                         PreMeshBuffer &p = collector.prebuffers[layer][i];
1167
1168                         applyTileColor(p);
1169
1170                         // Generate animation data
1171                         // - Cracks
1172                         if (p.layer.material_flags & MATERIAL_FLAG_CRACK) {
1173                                 // Find the texture name plus ^[crack:N:
1174                                 std::ostringstream os(std::ios::binary);
1175                                 os << m_tsrc->getTextureName(p.layer.texture_id) << "^[crack";
1176                                 if (p.layer.material_flags & MATERIAL_FLAG_CRACK_OVERLAY)
1177                                         os << "o";  // use ^[cracko
1178                                 u8 tiles = p.layer.scale;
1179                                 if (tiles > 1)
1180                                         os << ":" << (u32)tiles;
1181                                 os << ":" << (u32)p.layer.animation_frame_count << ":";
1182                                 m_crack_materials.insert(std::make_pair(
1183                                                 std::pair<u8, u32>(layer, i), os.str()));
1184                                 // Replace tile texture with the cracked one
1185                                 p.layer.texture = m_tsrc->getTextureForMesh(
1186                                                 os.str() + "0",
1187                                                 &p.layer.texture_id);
1188                         }
1189                         // - Texture animation
1190                         if (p.layer.material_flags & MATERIAL_FLAG_ANIMATION) {
1191                                 // Add to MapBlockMesh in order to animate these tiles
1192                                 m_animation_tiles[std::pair<u8, u32>(layer, i)] = p.layer;
1193                                 m_animation_frames[std::pair<u8, u32>(layer, i)] = 0;
1194                                 if (g_settings->getBool(
1195                                                 "desynchronize_mapblock_texture_animation")) {
1196                                         // Get starting position from noise
1197                                         m_animation_frame_offsets[std::pair<u8, u32>(layer, i)] =
1198                                                         100000 * (2.0 + noise3d(
1199                                                         data->m_blockpos.X, data->m_blockpos.Y,
1200                                                         data->m_blockpos.Z, 0));
1201                                 } else {
1202                                         // Play all synchronized
1203                                         m_animation_frame_offsets[std::pair<u8, u32>(layer, i)] = 0;
1204                                 }
1205                                 // Replace tile texture with the first animation frame
1206                                 p.layer.texture = (*p.layer.frames)[0].texture;
1207                         }
1208
1209                         if (!m_enable_shaders) {
1210                                 // Extract colors for day-night animation
1211                                 // Dummy sunlight to handle non-sunlit areas
1212                                 video::SColorf sunlight;
1213                                 get_sunlight_color(&sunlight, 0);
1214                                 u32 vertex_count = p.vertices.size();
1215                                 for (u32 j = 0; j < vertex_count; j++) {
1216                                         video::SColor *vc = &p.vertices[j].Color;
1217                                         video::SColor copy = *vc;
1218                                         if (vc->getAlpha() == 0) // No sunlight - no need to animate
1219                                                 final_color_blend(vc, copy, sunlight); // Finalize color
1220                                         else // Record color to animate
1221                                                 m_daynight_diffs[std::pair<u8, u32>(layer, i)][j] = copy;
1222
1223                                         // The sunlight ratio has been stored,
1224                                         // delete alpha (for the final rendering).
1225                                         vc->setAlpha(255);
1226                                 }
1227                         }
1228
1229                         // Create material
1230                         video::SMaterial material;
1231                         material.setFlag(video::EMF_LIGHTING, false);
1232                         material.setFlag(video::EMF_BACK_FACE_CULLING, true);
1233                         material.setFlag(video::EMF_BILINEAR_FILTER, false);
1234                         material.setFlag(video::EMF_FOG_ENABLE, true);
1235                         material.setTexture(0, p.layer.texture);
1236
1237                         if (m_enable_shaders) {
1238                                 material.MaterialType = m_shdrsrc->getShaderInfo(
1239                                                 p.layer.shader_id).material;
1240                                 p.layer.applyMaterialOptionsWithShaders(material);
1241                                 if (p.layer.normal_texture)
1242                                         material.setTexture(1, p.layer.normal_texture);
1243                                 material.setTexture(2, p.layer.flags_texture);
1244                         } else {
1245                                 p.layer.applyMaterialOptions(material);
1246                         }
1247
1248                         scene::SMesh *mesh = (scene::SMesh *)m_mesh[layer];
1249
1250                         // Create meshbuffer, add to mesh
1251                         if (m_use_tangent_vertices) {
1252                                 scene::SMeshBufferTangents *buf =
1253                                                 new scene::SMeshBufferTangents();
1254                                 buf->Material = material;
1255                                 buf->Vertices.reallocate(p.vertices.size());
1256                                 buf->Indices.reallocate(p.indices.size());
1257                                 for (const video::S3DVertex &v: p.vertices)
1258                                         buf->Vertices.push_back(video::S3DVertexTangents(v.Pos, v.Color, v.TCoords));
1259                                 for (u16 i: p.indices)
1260                                         buf->Indices.push_back(i);
1261                                 buf->recalculateBoundingBox();
1262                                 mesh->addMeshBuffer(buf);
1263                                 buf->drop();
1264                         } else {
1265                                 scene::SMeshBuffer *buf = new scene::SMeshBuffer();
1266                                 buf->Material = material;
1267                                 buf->append(&p.vertices[0], p.vertices.size(),
1268                                         &p.indices[0], p.indices.size());
1269                                 mesh->addMeshBuffer(buf);
1270                                 buf->drop();
1271                         }
1272                 }
1273
1274                 /*
1275                         Do some stuff to the mesh
1276                 */
1277                 m_camera_offset = camera_offset;
1278                 translateMesh(m_mesh[layer],
1279                         intToFloat(data->m_blockpos * MAP_BLOCKSIZE - camera_offset, BS));
1280
1281                 if (m_use_tangent_vertices) {
1282                         scene::IMeshManipulator* meshmanip =
1283                                 RenderingEngine::get_scene_manager()->getMeshManipulator();
1284                         meshmanip->recalculateTangents(m_mesh[layer], true, false, false);
1285                 }
1286
1287                 if (m_mesh[layer]) {
1288 #if 0
1289                         // Usually 1-700 faces and 1-7 materials
1290                         std::cout << "Updated MapBlock has " << fastfaces_new.size()
1291                                         << " faces and uses " << m_mesh[layer]->getMeshBufferCount()
1292                                         << " materials (meshbuffers)" << std::endl;
1293 #endif
1294
1295                         // Use VBO for mesh (this just would set this for ever buffer)
1296                         if (m_enable_vbo)
1297                                 m_mesh[layer]->setHardwareMappingHint(scene::EHM_STATIC);
1298                 }
1299         }
1300
1301         //std::cout<<"added "<<fastfaces.getSize()<<" faces."<<std::endl;
1302
1303         // Check if animation is required for this mesh
1304         m_has_animation =
1305                 !m_crack_materials.empty() ||
1306                 !m_daynight_diffs.empty() ||
1307                 !m_animation_tiles.empty();
1308
1309         esp_nodes = data->m_esp_nodes;
1310 }
1311
1312 MapBlockMesh::~MapBlockMesh()
1313 {
1314         for (scene::IMesh *m : m_mesh) {
1315                 if (m_enable_vbo && m)
1316                         for (u32 i = 0; i < m->getMeshBufferCount(); i++) {
1317                                 scene::IMeshBuffer *buf = m->getMeshBuffer(i);
1318                                 RenderingEngine::get_video_driver()->removeHardwareBuffer(buf);
1319                         }
1320                 m->drop();
1321                 m = NULL;
1322         }
1323         delete m_minimap_mapblock;
1324 }
1325
1326 bool MapBlockMesh::animate(bool faraway, float time, int crack,
1327         u32 daynight_ratio)
1328 {
1329         if (!m_has_animation) {
1330                 m_animation_force_timer = 100000;
1331                 return false;
1332         }
1333
1334         m_animation_force_timer = myrand_range(5, 100);
1335
1336         // Cracks
1337         if (crack != m_last_crack) {
1338                 for (auto &crack_material : m_crack_materials) {
1339                         scene::IMeshBuffer *buf = m_mesh[crack_material.first.first]->
1340                                 getMeshBuffer(crack_material.first.second);
1341                         std::string basename = crack_material.second;
1342
1343                         // Create new texture name from original
1344                         std::ostringstream os;
1345                         os << basename << crack;
1346                         u32 new_texture_id = 0;
1347                         video::ITexture *new_texture =
1348                                         m_tsrc->getTextureForMesh(os.str(), &new_texture_id);
1349                         buf->getMaterial().setTexture(0, new_texture);
1350
1351                         // If the current material is also animated,
1352                         // update animation info
1353                         auto anim_iter = m_animation_tiles.find(crack_material.first);
1354                         if (anim_iter != m_animation_tiles.end()) {
1355                                 TileLayer &tile = anim_iter->second;
1356                                 tile.texture = new_texture;
1357                                 tile.texture_id = new_texture_id;
1358                                 // force animation update
1359                                 m_animation_frames[crack_material.first] = -1;
1360                         }
1361                 }
1362
1363                 m_last_crack = crack;
1364         }
1365
1366         // Texture animation
1367         for (auto &animation_tile : m_animation_tiles) {
1368                 const TileLayer &tile = animation_tile.second;
1369                 // Figure out current frame
1370                 int frameoffset = m_animation_frame_offsets[animation_tile.first];
1371                 int frame = (int)(time * 1000 / tile.animation_frame_length_ms
1372                                 + frameoffset) % tile.animation_frame_count;
1373                 // If frame doesn't change, skip
1374                 if (frame == m_animation_frames[animation_tile.first])
1375                         continue;
1376
1377                 m_animation_frames[animation_tile.first] = frame;
1378
1379                 scene::IMeshBuffer *buf = m_mesh[animation_tile.first.first]->
1380                         getMeshBuffer(animation_tile.first.second);
1381
1382                 const FrameSpec &animation_frame = (*tile.frames)[frame];
1383                 buf->getMaterial().setTexture(0, animation_frame.texture);
1384                 if (m_enable_shaders) {
1385                         if (animation_frame.normal_texture)
1386                                 buf->getMaterial().setTexture(1,
1387                                         animation_frame.normal_texture);
1388                         buf->getMaterial().setTexture(2, animation_frame.flags_texture);
1389                 }
1390         }
1391
1392         // Day-night transition
1393         if (!m_enable_shaders && (daynight_ratio != m_last_daynight_ratio)) {
1394                 // Force reload mesh to VBO
1395                 if (m_enable_vbo)
1396                         for (scene::IMesh *m : m_mesh)
1397                                 m->setDirty();
1398                 video::SColorf day_color;
1399                 get_sunlight_color(&day_color, daynight_ratio);
1400
1401                 for (auto &daynight_diff : m_daynight_diffs) {
1402                         scene::IMeshBuffer *buf = m_mesh[daynight_diff.first.first]->
1403                                 getMeshBuffer(daynight_diff.first.second);
1404                         video::S3DVertex *vertices = (video::S3DVertex *)buf->getVertices();
1405                         for (const auto &j : daynight_diff.second)
1406                                 final_color_blend(&(vertices[j.first].Color), j.second,
1407                                                 day_color);
1408                 }
1409                 m_last_daynight_ratio = daynight_ratio;
1410         }
1411
1412         return true;
1413 }
1414
1415 void MapBlockMesh::updateCameraOffset(v3s16 camera_offset)
1416 {
1417         if (camera_offset != m_camera_offset) {
1418                 for (scene::IMesh *layer : m_mesh) {
1419                         translateMesh(layer,
1420                                 intToFloat(m_camera_offset - camera_offset, BS));
1421                         if (m_enable_vbo)
1422                                 layer->setDirty();
1423                 }
1424                 m_camera_offset = camera_offset;
1425         }
1426 }
1427
1428 video::SColor encode_light(u16 light, u8 emissive_light)
1429 {
1430         // Get components
1431         u32 day = (light & 0xff);
1432         u32 night = (light >> 8);
1433         // Add emissive light
1434         night += emissive_light * 2.5f;
1435         if (night > 255)
1436                 night = 255;
1437         // Since we don't know if the day light is sunlight or
1438         // artificial light, assume it is artificial when the night
1439         // light bank is also lit.
1440         if (day < night)
1441                 day = 0;
1442         else
1443                 day = day - night;
1444         u32 sum = day + night;
1445         // Ratio of sunlight:
1446         u32 r;
1447         if (sum > 0)
1448                 r = day * 255 / sum;
1449         else
1450                 r = 0;
1451         // Average light:
1452         float b = (day + night) / 2;
1453         return video::SColor(r, b, b, b);
1454 }