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 static void getTileInfo(
 792                 // Input:
 793                 MeshMakeData *data,
 794                 const v3s16 &p,
 795                 const v3s16 &face_dir,
 796                 // Output:
 797                 bool &makes_face,
 798                 v3s16 &p_corrected,
 799                 v3s16 &face_dir_corrected,
 800                 u16 *lights,
 801                 u8 &waving,
 802                 TileSpec &tile
 803         )
 804 {
 805         VoxelManipulator &vmanip = data->m_vmanip;
 806         const NodeDefManager *ndef = data->m_client->ndef();
 807         v3s16 blockpos_nodes = data->m_blockpos * MAP_BLOCKSIZE;
 808         content_t cXray = ndef->getId(g_settings->get("xray_node"));
 809         bool xray = g_settings->getBool("xray");
 810
 811         const MapNode &n0 = vmanip.getNodeRefUnsafe(blockpos_nodes + p);
 812
 813         content_t c0 = n0.getContent();
 814         if (xray && c0 == cXray)
 815                 c0 = CONTENT_AIR;
 816
 817         // Don't even try to get n1 if n0 is already CONTENT_IGNORE
 818         if (c0 == CONTENT_IGNORE) {
 819                 makes_face = false;
 820                 return;
 821         }
 822
 823         const MapNode &n1 = vmanip.getNodeRefUnsafeCheckFlags(blockpos_nodes + p + face_dir);
 824
 825         content_t c1 = n1.getContent();
 826         if (xray && c1 == cXray)
 827                 c1 = CONTENT_AIR;
 828
 829         if (c1 == CONTENT_IGNORE) {
 830                 makes_face = false;
 831                 return;
 832         }
 833
 834         // This is hackish
 835         bool equivalent = false;
 836         u8 mf = face_contents(c0, c1,
 837                         &equivalent, ndef);
 838
 839         if (mf == 0) {
 840                 makes_face = false;
 841                 return;
 842         }
 843
 844         makes_face = true;
 845
 846         MapNode n = n0;
 847
 848         if (mf == 1) {
 849                 p_corrected = p;
 850                 face_dir_corrected = face_dir;
 851         } else {
 852                 n = n1;
 853                 p_corrected = p + face_dir;
 854                 face_dir_corrected = -face_dir;
 855         }
 856
 857         getNodeTile(n, p_corrected, face_dir_corrected, data, tile);
 858         const ContentFeatures &f = ndef->get(n);
 859         waving = f.waving;
 860         tile.emissive_light = f.light_source;
 861
 862         // eg. water and glass
 863         if (equivalent) {
 864                 for (TileLayer &layer : tile.layers)
 865                         layer.material_flags |= MATERIAL_FLAG_BACKFACE_CULLING;
 866         }
 867
 868         if (!data->m_smooth_lighting) {
 869                 lights[0] = lights[1] = lights[2] = lights[3] =
 870                                 getFaceLight(n0, n1, face_dir, ndef);
 871         } else {
 872                 v3s16 vertex_dirs[4];
 873                 getNodeVertexDirs(face_dir_corrected, vertex_dirs);
 874
 875                 v3s16 light_p = blockpos_nodes + p_corrected;
 876                 for (u16 i = 0; i < 4; i++)
 877                         lights[i] = getSmoothLightSolid(light_p, face_dir_corrected, vertex_dirs[i], data);
 878         }
 879 }
 880
 881 /*
 882         startpos:
 883         translate_dir: unit vector with only one of x, y or z
 884         face_dir: unit vector with only one of x, y or z
 885 */
 886 static void updateFastFaceRow(
 887                 MeshMakeData *data,
 888                 const v3s16 &&startpos,
 889                 v3s16 translate_dir,
 890                 const v3f &&translate_dir_f,
 891                 const v3s16 &&face_dir,
 892                 std::vector<FastFace> &dest)
 893 {
 894         static thread_local const bool waving_liquids =
 895                 g_settings->getBool("enable_shaders") &&
 896                 g_settings->getBool("enable_waving_water");
 897
 898         v3s16 p = startpos;
 899
 900         u16 continuous_tiles_count = 1;
 901
 902         bool makes_face = false;
 903         v3s16 p_corrected;
 904         v3s16 face_dir_corrected;
 905         u16 lights[4] = {0, 0, 0, 0};
 906         u8 waving = 0;
 907         TileSpec tile;
 908
 909         // Get info of first tile
 910         getTileInfo(data, p, face_dir,
 911                         makes_face, p_corrected, face_dir_corrected,
 912                         lights, waving, tile);
 913
 914         // Unroll this variable which has a significant build cost
 915         TileSpec next_tile;
 916         for (u16 j = 0; j < MAP_BLOCKSIZE; j++) {
 917                 // If tiling can be done, this is set to false in the next step
 918                 bool next_is_different = true;
 919
 920                 bool next_makes_face = false;
 921                 v3s16 next_p_corrected;
 922                 v3s16 next_face_dir_corrected;
 923                 u16 next_lights[4] = {0, 0, 0, 0};
 924
 925                 // If at last position, there is nothing to compare to and
 926                 // the face must be drawn anyway
 927                 if (j != MAP_BLOCKSIZE - 1) {
 928                         p += translate_dir;
 929
 930                         getTileInfo(data, p, face_dir,
 931                                         next_makes_face, next_p_corrected,
 932                                         next_face_dir_corrected, next_lights,
 933                                         waving,
 934                                         next_tile);
 935
 936                         if (next_makes_face == makes_face
 937                                         && next_p_corrected == p_corrected + translate_dir
 938                                         && next_face_dir_corrected == face_dir_corrected
 939                                         && memcmp(next_lights, lights, sizeof(lights)) == 0
 940                                         // Don't apply fast faces to waving water.
 941                                         && (waving != 3 || !waving_liquids)
 942                                         && next_tile.isTileable(tile)) {
 943                                 next_is_different = false;
 944                                 continuous_tiles_count++;
 945                         }
 946                 }
 947                 if (next_is_different) {
 948                         /*
 949                                 Create a face if there should be one
 950                         */
 951                         if (makes_face) {
 952                                 // Floating point conversion of the position vector
 953                                 v3f pf(p_corrected.X, p_corrected.Y, p_corrected.Z);
 954                                 // Center point of face (kind of)
 955                                 v3f sp = pf - ((f32)continuous_tiles_count * 0.5f - 0.5f)
 956                                         * translate_dir_f;
 957                                 v3f scale(1, 1, 1);
 958
 959                                 if (translate_dir.X != 0)
 960                                         scale.X = continuous_tiles_count;
 961                                 if (translate_dir.Y != 0)
 962                                         scale.Y = continuous_tiles_count;
 963                                 if (translate_dir.Z != 0)
 964                                         scale.Z = continuous_tiles_count;
 965
 966                                 makeFastFace(tile, lights[0], lights[1], lights[2], lights[3],
 967                                                 pf, sp, face_dir_corrected, scale, dest);
 968                                 g_profiler->avg("Meshgen: Tiles per face [#]", continuous_tiles_count);
 969                         }
 970
 971                         continuous_tiles_count = 1;
 972                 }
 973
 974                 makes_face = next_makes_face;
 975                 p_corrected = next_p_corrected;
 976                 face_dir_corrected = next_face_dir_corrected;
 977                 memcpy(lights, next_lights, sizeof(lights));
 978                 if (next_is_different)
 979                         tile = std::move(next_tile); // faster than copy
 980         }
 981 }
 982
 983 static void updateAllFastFaceRows(MeshMakeData *data,
 984                 std::vector<FastFace> &dest)
 985 {
 986         /*
 987                 Go through every y,z and get top(y+) faces in rows of x+
 988         */
 989         for (s16 y = 0; y < MAP_BLOCKSIZE; y++)
 990         for (s16 z = 0; z < MAP_BLOCKSIZE; z++)
 991                 updateFastFaceRow(data,
 992                                 v3s16(0, y, z),
 993                                 v3s16(1, 0, 0), //dir
 994                                 v3f  (1, 0, 0),
 995                                 v3s16(0, 1, 0), //face dir
 996                                 dest);
 997
 998         /*
 999                 Go through every x,y and get right(x+) faces in rows of z+
1000         */
1001         for (s16 x = 0; x < MAP_BLOCKSIZE; x++)
1002         for (s16 y = 0; y < MAP_BLOCKSIZE; y++)
1003                 updateFastFaceRow(data,
1004                                 v3s16(x, y, 0),
1005                                 v3s16(0, 0, 1), //dir
1006                                 v3f  (0, 0, 1),
1007                                 v3s16(1, 0, 0), //face dir
1008                                 dest);
1009
1010         /*
1011                 Go through every y,z and get back(z+) faces in rows of x+
1012         */
1013         for (s16 z = 0; z < MAP_BLOCKSIZE; z++)
1014         for (s16 y = 0; y < MAP_BLOCKSIZE; y++)
1015                 updateFastFaceRow(data,
1016                                 v3s16(0, y, z),
1017                                 v3s16(1, 0, 0), //dir
1018                                 v3f  (1, 0, 0),
1019                                 v3s16(0, 0, 1), //face dir
1020                                 dest);
1021 }
1022
1023 static void applyTileColor(PreMeshBuffer &pmb)
1024 {
1025         video::SColor tc = pmb.layer.color;
1026         if (tc == video::SColor(0xFFFFFFFF))
1027                 return;
1028         for (video::S3DVertex &vertex : pmb.vertices) {
1029                 video::SColor *c = &vertex.Color;
1030                 c->set(c->getAlpha(),
1031                         c->getRed() * tc.getRed() / 255,
1032                         c->getGreen() * tc.getGreen() / 255,
1033                         c->getBlue() * tc.getBlue() / 255);
1034         }
1035 }
1036
1037 /*
1038         MapBlockMesh
1039 */
1040
1041 MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset):
1042         m_minimap_mapblock(NULL),
1043         m_tsrc(data->m_client->getTextureSource()),
1044         m_shdrsrc(data->m_client->getShaderSource()),
1045         m_animation_force_timer(0), // force initial animation
1046         m_last_crack(-1),
1047         m_last_daynight_ratio((u32) -1)
1048 {
1049         for (auto &m : m_mesh)
1050                 m = new scene::SMesh();
1051         m_enable_shaders = data->m_use_shaders;
1052         m_use_tangent_vertices = data->m_use_tangent_vertices;
1053         m_enable_vbo = g_settings->getBool("enable_vbo");
1054
1055         if (g_settings->getBool("enable_minimap")) {
1056                 m_minimap_mapblock = new MinimapMapblock;
1057                 m_minimap_mapblock->getMinimapNodes(
1058                         &data->m_vmanip, data->m_blockpos * MAP_BLOCKSIZE);
1059         }
1060
1061         // 4-21ms for MAP_BLOCKSIZE=16  (NOTE: probably outdated)
1062         // 24-155ms for MAP_BLOCKSIZE=32  (NOTE: probably outdated)
1063         //TimeTaker timer1("MapBlockMesh()");
1064
1065         std::vector<FastFace> fastfaces_new;
1066         fastfaces_new.reserve(512);
1067
1068         /*
1069                 We are including the faces of the trailing edges of the block.
1070                 This means that when something changes, the caller must
1071                 also update the meshes of the blocks at the leading edges.
1072
1073                 NOTE: This is the slowest part of this method.
1074         */
1075         {
1076                 // 4-23ms for MAP_BLOCKSIZE=16  (NOTE: probably outdated)
1077                 //TimeTaker timer2("updateAllFastFaceRows()");
1078                 updateAllFastFaceRows(data, fastfaces_new);
1079         }
1080         // End of slow part
1081
1082         /*
1083                 Convert FastFaces to MeshCollector
1084         */
1085
1086         MeshCollector collector;
1087
1088         {
1089                 // avg 0ms (100ms spikes when loading textures the first time)
1090                 // (NOTE: probably outdated)
1091                 //TimeTaker timer2("MeshCollector building");
1092
1093                 for (const FastFace &f : fastfaces_new) {
1094                         static const u16 indices[] = {0, 1, 2, 2, 3, 0};
1095                         static const u16 indices_alternate[] = {0, 1, 3, 2, 3, 1};
1096                         const u16 *indices_p =
1097                                 f.vertex_0_2_connected ? indices : indices_alternate;
1098                         collector.append(f.tile, f.vertices, 4, indices_p, 6);
1099                 }
1100         }
1101
1102         /*
1103                 Add special graphics:
1104                 - torches
1105                 - flowing water
1106                 - fences
1107                 - whatever
1108         */
1109
1110         {
1111                 MapblockMeshGenerator generator(data, &collector);
1112                 generator.generate();
1113         }
1114
1115         /*
1116                 Convert MeshCollector to SMesh
1117         */
1118
1119         for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
1120                 for(u32 i = 0; i < collector.prebuffers[layer].size(); i++)
1121                 {
1122                         PreMeshBuffer &p = collector.prebuffers[layer][i];
1123
1124                         applyTileColor(p);
1125
1126                         // Generate animation data
1127                         // - Cracks
1128                         if (p.layer.material_flags & MATERIAL_FLAG_CRACK) {
1129                                 // Find the texture name plus ^[crack:N:
1130                                 std::ostringstream os(std::ios::binary);
1131                                 os << m_tsrc->getTextureName(p.layer.texture_id) << "^[crack";
1132                                 if (p.layer.material_flags & MATERIAL_FLAG_CRACK_OVERLAY)
1133                                         os << "o";  // use ^[cracko
1134                                 u8 tiles = p.layer.scale;
1135                                 if (tiles > 1)
1136                                         os << ":" << (u32)tiles;
1137                                 os << ":" << (u32)p.layer.animation_frame_count << ":";
1138                                 m_crack_materials.insert(std::make_pair(
1139                                                 std::pair<u8, u32>(layer, i), os.str()));
1140                                 // Replace tile texture with the cracked one
1141                                 p.layer.texture = m_tsrc->getTextureForMesh(
1142                                                 os.str() + "0",
1143                                                 &p.layer.texture_id);
1144                         }
1145                         // - Texture animation
1146                         if (p.layer.material_flags & MATERIAL_FLAG_ANIMATION) {
1147                                 // Add to MapBlockMesh in order to animate these tiles
1148                                 m_animation_tiles[std::pair<u8, u32>(layer, i)] = p.layer;
1149                                 m_animation_frames[std::pair<u8, u32>(layer, i)] = 0;
1150                                 if (g_settings->getBool(
1151                                                 "desynchronize_mapblock_texture_animation")) {
1152                                         // Get starting position from noise
1153                                         m_animation_frame_offsets[std::pair<u8, u32>(layer, i)] =
1154                                                         100000 * (2.0 + noise3d(
1155                                                         data->m_blockpos.X, data->m_blockpos.Y,
1156                                                         data->m_blockpos.Z, 0));
1157                                 } else {
1158                                         // Play all synchronized
1159                                         m_animation_frame_offsets[std::pair<u8, u32>(layer, i)] = 0;
1160                                 }
1161                                 // Replace tile texture with the first animation frame
1162                                 p.layer.texture = (*p.layer.frames)[0].texture;
1163                         }
1164
1165                         if (!m_enable_shaders) {
1166                                 // Extract colors for day-night animation
1167                                 // Dummy sunlight to handle non-sunlit areas
1168                                 video::SColorf sunlight;
1169                                 get_sunlight_color(&sunlight, 0);
1170                                 u32 vertex_count = p.vertices.size();
1171                                 for (u32 j = 0; j < vertex_count; j++) {
1172                                         video::SColor *vc = &p.vertices[j].Color;
1173                                         video::SColor copy = *vc;
1174                                         if (vc->getAlpha() == 0) // No sunlight - no need to animate
1175                                                 final_color_blend(vc, copy, sunlight); // Finalize color
1176                                         else // Record color to animate
1177                                                 m_daynight_diffs[std::pair<u8, u32>(layer, i)][j] = copy;
1178
1179                                         // The sunlight ratio has been stored,
1180                                         // delete alpha (for the final rendering).
1181                                         vc->setAlpha(255);
1182                                 }
1183                         }
1184
1185                         // Create material
1186                         video::SMaterial material;
1187                         material.setFlag(video::EMF_LIGHTING, false);
1188                         material.setFlag(video::EMF_BACK_FACE_CULLING, true);
1189                         material.setFlag(video::EMF_BILINEAR_FILTER, false);
1190                         material.setFlag(video::EMF_FOG_ENABLE, true);
1191                         material.setTexture(0, p.layer.texture);
1192
1193                         if (m_enable_shaders) {
1194                                 material.MaterialType = m_shdrsrc->getShaderInfo(
1195                                                 p.layer.shader_id).material;
1196                                 p.layer.applyMaterialOptionsWithShaders(material);
1197                                 if (p.layer.normal_texture)
1198                                         material.setTexture(1, p.layer.normal_texture);
1199                                 material.setTexture(2, p.layer.flags_texture);
1200                         } else {
1201                                 p.layer.applyMaterialOptions(material);
1202                         }
1203
1204                         scene::SMesh *mesh = (scene::SMesh *)m_mesh[layer];
1205
1206                         // Create meshbuffer, add to mesh
1207                         if (m_use_tangent_vertices) {
1208                                 scene::SMeshBufferTangents *buf =
1209                                                 new scene::SMeshBufferTangents();
1210                                 buf->Material = material;
1211                                 buf->Vertices.reallocate(p.vertices.size());
1212                                 buf->Indices.reallocate(p.indices.size());
1213                                 for (const video::S3DVertex &v: p.vertices)
1214                                         buf->Vertices.push_back(video::S3DVertexTangents(v.Pos, v.Color, v.TCoords));
1215                                 for (u16 i: p.indices)
1216                                         buf->Indices.push_back(i);
1217                                 buf->recalculateBoundingBox();
1218                                 mesh->addMeshBuffer(buf);
1219                                 buf->drop();
1220                         } else {
1221                                 scene::SMeshBuffer *buf = new scene::SMeshBuffer();
1222                                 buf->Material = material;
1223                                 buf->append(&p.vertices[0], p.vertices.size(),
1224                                         &p.indices[0], p.indices.size());
1225                                 mesh->addMeshBuffer(buf);
1226                                 buf->drop();
1227                         }
1228                 }
1229
1230                 /*
1231                         Do some stuff to the mesh
1232                 */
1233                 m_camera_offset = camera_offset;
1234                 translateMesh(m_mesh[layer],
1235                         intToFloat(data->m_blockpos * MAP_BLOCKSIZE - camera_offset, BS));
1236
1237                 if (m_use_tangent_vertices) {
1238                         scene::IMeshManipulator* meshmanip =
1239                                 RenderingEngine::get_scene_manager()->getMeshManipulator();
1240                         meshmanip->recalculateTangents(m_mesh[layer], true, false, false);
1241                 }
1242
1243                 if (m_mesh[layer]) {
1244 #if 0
1245                         // Usually 1-700 faces and 1-7 materials
1246                         std::cout << "Updated MapBlock has " << fastfaces_new.size()
1247                                         << " faces and uses " << m_mesh[layer]->getMeshBufferCount()
1248                                         << " materials (meshbuffers)" << std::endl;
1249 #endif
1250
1251                         // Use VBO for mesh (this just would set this for ever buffer)
1252                         if (m_enable_vbo)
1253                                 m_mesh[layer]->setHardwareMappingHint(scene::EHM_STATIC);
1254                 }
1255         }
1256
1257         //std::cout<<"added "<<fastfaces.getSize()<<" faces."<<std::endl;
1258
1259         // Check if animation is required for this mesh
1260         m_has_animation =
1261                 !m_crack_materials.empty() ||
1262                 !m_daynight_diffs.empty() ||
1263                 !m_animation_tiles.empty();
1264 }
1265
1266 MapBlockMesh::~MapBlockMesh()
1267 {
1268         for (scene::IMesh *m : m_mesh) {
1269                 if (m_enable_vbo && m)
1270                         for (u32 i = 0; i < m->getMeshBufferCount(); i++) {
1271                                 scene::IMeshBuffer *buf = m->getMeshBuffer(i);
1272                                 RenderingEngine::get_video_driver()->removeHardwareBuffer(buf);
1273                         }
1274                 m->drop();
1275                 m = NULL;
1276         }
1277         delete m_minimap_mapblock;
1278 }
1279
1280 bool MapBlockMesh::animate(bool faraway, float time, int crack,
1281         u32 daynight_ratio)
1282 {
1283         if (!m_has_animation) {
1284                 m_animation_force_timer = 100000;
1285                 return false;
1286         }
1287
1288         m_animation_force_timer = myrand_range(5, 100);
1289
1290         // Cracks
1291         if (crack != m_last_crack) {
1292                 for (auto &crack_material : m_crack_materials) {
1293                         scene::IMeshBuffer *buf = m_mesh[crack_material.first.first]->
1294                                 getMeshBuffer(crack_material.first.second);
1295                         std::string basename = crack_material.second;
1296
1297                         // Create new texture name from original
1298                         std::ostringstream os;
1299                         os << basename << crack;
1300                         u32 new_texture_id = 0;
1301                         video::ITexture *new_texture =
1302                                         m_tsrc->getTextureForMesh(os.str(), &new_texture_id);
1303                         buf->getMaterial().setTexture(0, new_texture);
1304
1305                         // If the current material is also animated,
1306                         // update animation info
1307                         auto anim_iter = m_animation_tiles.find(crack_material.first);
1308                         if (anim_iter != m_animation_tiles.end()) {
1309                                 TileLayer &tile = anim_iter->second;
1310                                 tile.texture = new_texture;
1311                                 tile.texture_id = new_texture_id;
1312                                 // force animation update
1313                                 m_animation_frames[crack_material.first] = -1;
1314                         }
1315                 }
1316
1317                 m_last_crack = crack;
1318         }
1319
1320         // Texture animation
1321         for (auto &animation_tile : m_animation_tiles) {
1322                 const TileLayer &tile = animation_tile.second;
1323                 // Figure out current frame
1324                 int frameoffset = m_animation_frame_offsets[animation_tile.first];
1325                 int frame = (int)(time * 1000 / tile.animation_frame_length_ms
1326                                 + frameoffset) % tile.animation_frame_count;
1327                 // If frame doesn't change, skip
1328                 if (frame == m_animation_frames[animation_tile.first])
1329                         continue;
1330
1331                 m_animation_frames[animation_tile.first] = frame;
1332
1333                 scene::IMeshBuffer *buf = m_mesh[animation_tile.first.first]->
1334                         getMeshBuffer(animation_tile.first.second);
1335
1336                 const FrameSpec &animation_frame = (*tile.frames)[frame];
1337                 buf->getMaterial().setTexture(0, animation_frame.texture);
1338                 if (m_enable_shaders) {
1339                         if (animation_frame.normal_texture)
1340                                 buf->getMaterial().setTexture(1,
1341                                         animation_frame.normal_texture);
1342                         buf->getMaterial().setTexture(2, animation_frame.flags_texture);
1343                 }
1344         }
1345
1346         // Day-night transition
1347         if (!m_enable_shaders && (daynight_ratio != m_last_daynight_ratio)) {
1348                 // Force reload mesh to VBO
1349                 if (m_enable_vbo)
1350                         for (scene::IMesh *m : m_mesh)
1351                                 m->setDirty();
1352                 video::SColorf day_color;
1353                 get_sunlight_color(&day_color, daynight_ratio);
1354
1355                 for (auto &daynight_diff : m_daynight_diffs) {
1356                         scene::IMeshBuffer *buf = m_mesh[daynight_diff.first.first]->
1357                                 getMeshBuffer(daynight_diff.first.second);
1358                         video::S3DVertex *vertices = (video::S3DVertex *)buf->getVertices();
1359                         for (const auto &j : daynight_diff.second)
1360                                 final_color_blend(&(vertices[j.first].Color), j.second,
1361                                                 day_color);
1362                 }
1363                 m_last_daynight_ratio = daynight_ratio;
1364         }
1365
1366         return true;
1367 }
1368
1369 void MapBlockMesh::updateCameraOffset(v3s16 camera_offset)
1370 {
1371         if (camera_offset != m_camera_offset) {
1372                 for (scene::IMesh *layer : m_mesh) {
1373                         translateMesh(layer,
1374                                 intToFloat(m_camera_offset - camera_offset, BS));
1375                         if (m_enable_vbo)
1376                                 layer->setDirty();
1377                 }
1378                 m_camera_offset = camera_offset;
1379         }
1380 }
1381
1382 video::SColor encode_light(u16 light, u8 emissive_light)
1383 {
1384         // Get components
1385         u32 day = (light & 0xff);
1386         u32 night = (light >> 8);
1387         // Add emissive light
1388         night += emissive_light * 2.5f;
1389         if (night > 255)
1390                 night = 255;
1391         // Since we don't know if the day light is sunlight or
1392         // artificial light, assume it is artificial when the night
1393         // light bank is also lit.
1394         if (day < night)
1395                 day = 0;
1396         else
1397                 day = day - night;
1398         u32 sum = day + night;
1399         // Ratio of sunlight:
1400         u32 r;
1401         if (sum > 0)
1402                 r = day * 255 / sum;
1403         else
1404                 r = 0;
1405         // Average light:
1406         float b = (day + night) / 2;
1407         return video::SColor(r, b, b, b);
1408 }