X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapblock_mesh.cpp;h=bdf791c0bf1aae335cff5406c264cda47964ad1f;hb=4be46aeeb17c42718ecea14934e24d77772b4126;hp=f76033ea8a5bb16b8fab0ad27275a6b4fd8e32ef;hpb=d4e0c0f9b818120286369b33b1bdb5eb6ece7a83;p=dragonfireclient.git diff --git a/src/mapblock_mesh.cpp b/src/mapblock_mesh.cpp index f76033ea8..bdf791c0b 100644 --- a/src/mapblock_mesh.cpp +++ b/src/mapblock_mesh.cpp @@ -18,19 +18,17 @@ with this program; if not, write to the Free Software Foundation, Inc., */ #include "mapblock_mesh.h" -#include "light.h" +#include "client.h" #include "mapblock.h" #include "map.h" #include "profiler.h" -#include "nodedef.h" +#include "shader.h" #include "mesh.h" #include "minimap.h" #include "content_mapblock.h" -#include "noise.h" -#include "shader.h" -#include "settings.h" #include "util/directiontables.h" -#include +#include "client/renderingengine.h" +#include /* MeshMakeData @@ -38,59 +36,47 @@ with this program; if not, write to the Free Software Foundation, Inc., MeshMakeData::MeshMakeData(Client *client, bool use_shaders, bool use_tangent_vertices): - m_vmanip(), - m_blockpos(-1337,-1337,-1337), - m_crack_pos_relative(-1337, -1337, -1337), - m_smooth_lighting(false), - m_show_hud(false), m_client(client), m_use_shaders(use_shaders), m_use_tangent_vertices(use_tangent_vertices) {} -void MeshMakeData::fill(MapBlock *block) +void MeshMakeData::fillBlockDataBegin(const v3s16 &blockpos) { - m_blockpos = block->getPos(); + m_blockpos = blockpos; v3s16 blockpos_nodes = m_blockpos*MAP_BLOCKSIZE; - /* - Copy data - */ - - // Allocate this block + neighbors m_vmanip.clear(); VoxelArea voxel_area(blockpos_nodes - v3s16(1,1,1) * MAP_BLOCKSIZE, blockpos_nodes + v3s16(1,1,1) * MAP_BLOCKSIZE*2-v3s16(1,1,1)); m_vmanip.addArea(voxel_area); +} - { - //TimeTaker timer("copy central block data"); - // 0ms +void MeshMakeData::fillBlockData(const v3s16 &block_offset, MapNode *data) +{ + v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE); + VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1)); - // Copy our data - block->copyTo(m_vmanip); - } - { - //TimeTaker timer("copy neighbor block data"); - // 0ms + v3s16 bp = m_blockpos + block_offset; + v3s16 blockpos_nodes = bp * MAP_BLOCKSIZE; + m_vmanip.copyFrom(data, data_area, v3s16(0,0,0), blockpos_nodes, data_size); +} - /* - Copy neighbors. This is lightning fast. - Copying only the borders would be *very* slow. - */ +void MeshMakeData::fill(MapBlock *block) +{ + fillBlockDataBegin(block->getPos()); - // Get map - Map *map = block->getParent(); + fillBlockData(v3s16(0,0,0), block->getData()); - for(u16 i=0; i<26; i++) - { - const v3s16 &dir = g_26dirs[i]; - v3s16 bp = m_blockpos + dir; - MapBlock *b = map->getBlockNoCreateNoEx(bp); - if(b) - b->copyTo(m_vmanip); - } + // Get map for reading neighbor blocks + Map *map = block->getParent(); + + for (const v3s16 &dir : g_26dirs) { + v3s16 bp = m_blockpos + dir; + MapBlock *b = map->getBlockNoCreateNoEx(bp); + if(b) + fillBlockData(dir, b->getData()); } } @@ -112,14 +98,10 @@ void MeshMakeData::fillSingleNode(MapNode *node) MapNode *data = new MapNode[volume]; for(s32 i = 0; i < volume; i++) { - if(i == our_node_index) - { + if (i == our_node_index) data[i] = *node; - } else - { data[i] = MapNode(CONTENT_AIR, LIGHT_MAX, 0); - } } m_vmanip.copyFrom(data, area, area.MinEdge, area.MinEdge, area.getExtent()); delete[] data; @@ -127,7 +109,7 @@ void MeshMakeData::fillSingleNode(MapNode *node) void MeshMakeData::setCrack(int crack_level, v3s16 crack_pos) { - if(crack_level >= 0) + if (crack_level >= 0) m_crack_pos_relative = crack_pos - m_blockpos*MAP_BLOCKSIZE; } @@ -145,21 +127,11 @@ void MeshMakeData::setSmoothLighting(bool smooth_lighting) Single light bank. */ static u8 getInteriorLight(enum LightBank bank, MapNode n, s32 increment, - INodeDefManager *ndef) + const NodeDefManager *ndef) { u8 light = n.getLight(bank, ndef); - - while(increment > 0) - { - light = undiminish_light(light); - --increment; - } - while(increment < 0) - { - light = diminish_light(light); - ++increment; - } - + if (light > 0) + light = rangelim(light + increment, 0, LIGHT_SUN); return decode_light(light); } @@ -167,7 +139,7 @@ static u8 getInteriorLight(enum LightBank bank, MapNode n, s32 increment, Calculate non-smooth lighting at interior of node. Both light banks. */ -u16 getInteriorLight(MapNode n, s32 increment, INodeDefManager *ndef) +u16 getInteriorLight(MapNode n, s32 increment, const NodeDefManager *ndef) { u16 day = getInteriorLight(LIGHTBANK_DAY, n, increment, ndef); u16 night = getInteriorLight(LIGHTBANK_NIGHT, n, increment, ndef); @@ -179,7 +151,7 @@ u16 getInteriorLight(MapNode n, s32 increment, INodeDefManager *ndef) Single light bank. */ static u8 getFaceLight(enum LightBank bank, MapNode n, MapNode n2, - v3s16 face_dir, INodeDefManager *ndef) + v3s16 face_dir, const NodeDefManager *ndef) { u8 light; u8 l1 = n.getLight(bank, ndef); @@ -202,7 +174,8 @@ static u8 getFaceLight(enum LightBank bank, MapNode n, MapNode n2, Calculate non-smooth lighting at face of node. Both light banks. */ -u16 getFaceLight(MapNode n, MapNode n2, v3s16 face_dir, INodeDefManager *ndef) +u16 getFaceLight(MapNode n, MapNode n2, v3s16 face_dir, + const NodeDefManager *ndef) { u16 day = getFaceLight(LIGHTBANK_DAY, n, n2, face_dir, ndef); u16 night = getFaceLight(LIGHTBANK_NIGHT, n, n2, face_dir, ndef); @@ -213,20 +186,10 @@ u16 getFaceLight(MapNode n, MapNode n2, v3s16 face_dir, INodeDefManager *ndef) Calculate smooth lighting at the XYZ- corner of p. Both light banks */ -static u16 getSmoothLightCombined(v3s16 p, MeshMakeData *data) +static u16 getSmoothLightCombined(const v3s16 &p, + const std::array &dirs, MeshMakeData *data) { - static const v3s16 dirs8[8] = { - v3s16(0,0,0), - v3s16(0,0,1), - v3s16(0,1,0), - v3s16(0,1,1), - v3s16(1,0,0), - v3s16(1,1,0), - v3s16(1,0,1), - v3s16(1,1,1), - }; - - INodeDefManager *ndef = data->m_client->ndef(); + const NodeDefManager *ndef = data->m_client->ndef(); u16 ambient_occlusion = 0; u16 light_count = 0; @@ -234,15 +197,14 @@ static u16 getSmoothLightCombined(v3s16 p, MeshMakeData *data) u16 light_day = 0; u16 light_night = 0; - for (u32 i = 0; i < 8; i++) - { - MapNode n = data->m_vmanip.getNodeNoExNoEmerge(p - dirs8[i]); - - // if it's CONTENT_IGNORE we can't do any light calculations - if (n.getContent() == CONTENT_IGNORE) { - continue; + auto add_node = [&] (u8 i, bool obstructed = false) -> bool { + if (obstructed) { + ambient_occlusion++; + return false; } - + MapNode n = data->m_vmanip.getNodeNoExNoEmerge(p + dirs[i]); + if (n.getContent() == CONTENT_IGNORE) + return true; const ContentFeatures &f = ndef->get(n); if (f.light_source > light_source_max) light_source_max = f.light_source; @@ -254,17 +216,36 @@ static u16 getSmoothLightCombined(v3s16 p, MeshMakeData *data) } else { ambient_occlusion++; } - } + return f.light_propagates; + }; - if(light_count == 0) - return 0xffff; + std::array obstructed = {{ 1, 1, 1, 1 }}; + add_node(0); + bool opaque1 = !add_node(1); + bool opaque2 = !add_node(2); + bool opaque3 = !add_node(3); + obstructed[0] = opaque1 && opaque2; + obstructed[1] = opaque1 && opaque3; + obstructed[2] = opaque2 && opaque3; + for (u8 k = 0; k < 3; ++k) + if (add_node(k + 4, obstructed[k])) + obstructed[3] = false; + if (add_node(7, obstructed[3])) { // wrap light around nodes + ambient_occlusion -= 3; + for (u8 k = 0; k < 3; ++k) + add_node(k + 4, !obstructed[k]); + } - light_day /= light_count; - light_night /= light_count; + if (light_count == 0) { + light_day = light_night = 0; + } else { + light_day /= light_count; + light_night /= light_count; + } // Boost brightness around light sources bool skip_ambient_occlusion_day = false; - if(decode_light(light_source_max) >= light_day) { + if (decode_light(light_source_max) >= light_day) { light_day = decode_light(light_source_max); skip_ambient_occlusion_day = true; } @@ -275,13 +256,12 @@ static u16 getSmoothLightCombined(v3s16 p, MeshMakeData *data) skip_ambient_occlusion_night = true; } - if (ambient_occlusion > 4) - { - static const float ao_gamma = rangelim( + if (ambient_occlusion > 4) { + static thread_local const float ao_gamma = rangelim( g_settings->getFloat("ambient_occlusion_gamma"), 0.25, 4.0); // Table of gamma space multiply factors. - static const float light_amount[3] = { + static thread_local const float light_amount[3] = { powf(0.75, 1.0 / ao_gamma), powf(0.5, 1.0 / ao_gamma), powf(0.25, 1.0 / ao_gamma) @@ -291,9 +271,11 @@ static u16 getSmoothLightCombined(v3s16 p, MeshMakeData *data) ambient_occlusion -= 5; if (!skip_ambient_occlusion_day) - light_day = rangelim(core::round32(light_day*light_amount[ambient_occlusion]), 0, 255); + light_day = rangelim(core::round32( + light_day * light_amount[ambient_occlusion]), 0, 255); if (!skip_ambient_occlusion_night) - light_night = rangelim(core::round32(light_night*light_amount[ambient_occlusion]), 0, 255); + light_night = rangelim(core::round32( + light_night * light_amount[ambient_occlusion]), 0, 255); } return light_day | (light_night << 8); @@ -302,17 +284,34 @@ static u16 getSmoothLightCombined(v3s16 p, MeshMakeData *data) /* Calculate smooth lighting at the given corner of p. Both light banks. + Node at p is solid, and thus the lighting is face-dependent. */ -u16 getSmoothLight(v3s16 p, v3s16 corner, MeshMakeData *data) +u16 getSmoothLightSolid(const v3s16 &p, const v3s16 &face_dir, const v3s16 &corner, MeshMakeData *data) { - if(corner.X == 1) p.X += 1; - // else corner.X == -1 - if(corner.Y == 1) p.Y += 1; - // else corner.Y == -1 - if(corner.Z == 1) p.Z += 1; - // else corner.Z == -1 - - return getSmoothLightCombined(p, data); + return getSmoothLightTransparent(p + face_dir, corner - 2 * face_dir, data); +} + +/* + Calculate smooth lighting at the given corner of p. + Both light banks. + Node at p is not solid, and the lighting is not face-dependent. +*/ +u16 getSmoothLightTransparent(const v3s16 &p, const v3s16 &corner, MeshMakeData *data) +{ + const std::array dirs = {{ + // Always shine light + v3s16(0,0,0), + v3s16(corner.X,0,0), + v3s16(0,corner.Y,0), + v3s16(0,0,corner.Z), + + // Can be obstructed + v3s16(corner.X,corner.Y,0), + v3s16(corner.X,0,corner.Z), + v3s16(0,corner.Y,corner.Z), + v3s16(corner.X,corner.Y,corner.Z) + }}; + return getSmoothLightCombined(p, dirs, data); } void get_sunlight_color(video::SColorf *sunlight, u32 daynight_ratio){ @@ -329,7 +328,7 @@ void final_color_blend(video::SColor *result, video::SColorf dayLight; get_sunlight_color(&dayLight, daynight_ratio); final_color_blend(result, - encode_light_and_color(light, video::SColor(0xFFFFFFFF), 0), dayLight); + encode_light(light, 0), dayLight); } void final_color_blend(video::SColor *result, @@ -375,49 +374,38 @@ static void getNodeVertexDirs(v3s16 dir, v3s16 *vertex_dirs) 2: top-left 3: top-right */ - if(dir == v3s16(0,0,1)) - { + if (dir == v3s16(0, 0, 1)) { // If looking towards z+, this is the face that is behind // the center point, facing towards z+. vertex_dirs[0] = v3s16(-1,-1, 1); vertex_dirs[1] = v3s16( 1,-1, 1); vertex_dirs[2] = v3s16( 1, 1, 1); vertex_dirs[3] = v3s16(-1, 1, 1); - } - else if(dir == v3s16(0,0,-1)) - { + } else if (dir == v3s16(0, 0, -1)) { // faces towards Z- vertex_dirs[0] = v3s16( 1,-1,-1); vertex_dirs[1] = v3s16(-1,-1,-1); vertex_dirs[2] = v3s16(-1, 1,-1); vertex_dirs[3] = v3s16( 1, 1,-1); - } - else if(dir == v3s16(1,0,0)) - { + } else if (dir == v3s16(1, 0, 0)) { // faces towards X+ vertex_dirs[0] = v3s16( 1,-1, 1); vertex_dirs[1] = v3s16( 1,-1,-1); vertex_dirs[2] = v3s16( 1, 1,-1); vertex_dirs[3] = v3s16( 1, 1, 1); - } - else if(dir == v3s16(-1,0,0)) - { + } else if (dir == v3s16(-1, 0, 0)) { // faces towards X- vertex_dirs[0] = v3s16(-1,-1,-1); vertex_dirs[1] = v3s16(-1,-1, 1); vertex_dirs[2] = v3s16(-1, 1, 1); vertex_dirs[3] = v3s16(-1, 1,-1); - } - else if(dir == v3s16(0,1,0)) - { + } else if (dir == v3s16(0, 1, 0)) { // faces towards Y+ (assume Z- as "down" in texture) vertex_dirs[0] = v3s16( 1, 1,-1); vertex_dirs[1] = v3s16(-1, 1,-1); vertex_dirs[2] = v3s16(-1, 1, 1); vertex_dirs[3] = v3s16( 1, 1, 1); - } - else if(dir == v3s16(0,-1,0)) - { + } else if (dir == v3s16(0, -1, 0)) { // faces towards Y- (assume Z+ as "down" in texture) vertex_dirs[0] = v3s16( 1,-1, 1); vertex_dirs[1] = v3s16(-1,-1, 1); @@ -426,31 +414,65 @@ static void getNodeVertexDirs(v3s16 dir, v3s16 *vertex_dirs) } } +static void getNodeTextureCoords(v3f base, const v3f &scale, v3s16 dir, float *u, float *v) +{ + if (dir.X > 0 || dir.Y > 0 || dir.Z < 0) + base -= scale; + if (dir == v3s16(0,0,1)) { + *u = -base.X - 1; + *v = -base.Y - 1; + } else if (dir == v3s16(0,0,-1)) { + *u = base.X + 1; + *v = -base.Y - 2; + } else if (dir == v3s16(1,0,0)) { + *u = base.Z + 1; + *v = -base.Y - 2; + } else if (dir == v3s16(-1,0,0)) { + *u = -base.Z - 1; + *v = -base.Y - 1; + } else if (dir == v3s16(0,1,0)) { + *u = base.X + 1; + *v = -base.Z - 2; + } else if (dir == v3s16(0,-1,0)) { + *u = base.X; + *v = base.Z; + } +} + struct FastFace { - TileSpec tile; + TileLayer layer; video::S3DVertex vertices[4]; // Precalculated vertices + /*! + * The face is divided into two triangles. If this is true, + * vertices 0 and 2 are connected, othervise vertices 1 and 3 + * are connected. + */ + bool vertex_0_2_connected; + u8 layernum; + bool world_aligned; }; -static void makeFastFace(TileSpec tile, u16 li0, u16 li1, u16 li2, u16 li3, - v3f p, v3s16 dir, v3f scale, std::vector &dest) +static void makeFastFace(const TileSpec &tile, u16 li0, u16 li1, u16 li2, u16 li3, + v3f tp, v3f p, v3s16 dir, v3f scale, std::vector &dest) { // Position is at the center of the cube. v3f pos = p * BS; - float x0 = 0.0; - float y0 = 0.0; - float w = 1.0; - float h = 1.0; + float x0 = 0.0f; + float y0 = 0.0f; + float w = 1.0f; + float h = 1.0f; v3f vertex_pos[4]; v3s16 vertex_dirs[4]; getNodeVertexDirs(dir, vertex_dirs); + if (tile.world_aligned) + getNodeTextureCoords(tp, scale, dir, &x0, &y0); v3s16 t; u16 t1; - switch (tile.rotation) - { + switch (tile.rotation) { case 0: break; case 1: //R90 @@ -459,11 +481,11 @@ static void makeFastFace(TileSpec tile, u16 li0, u16 li1, u16 li2, u16 li3, vertex_dirs[3] = vertex_dirs[2]; vertex_dirs[2] = vertex_dirs[1]; vertex_dirs[1] = t; - t1=li0; - li0=li3; - li3=li2; - li2=li1; - li1=t1; + t1 = li0; + li0 = li3; + li3 = li2; + li2 = li1; + li1 = t1; break; case 2: //R180 t = vertex_dirs[0]; @@ -559,51 +581,75 @@ static void makeFastFace(TileSpec tile, u16 li0, u16 li1, u16 li2, u16 li3, break; } - for(u16 i=0; i<4; i++) - { + for (u16 i = 0; i < 4; i++) { vertex_pos[i] = v3f( - BS/2*vertex_dirs[i].X, - BS/2*vertex_dirs[i].Y, - BS/2*vertex_dirs[i].Z + BS / 2 * vertex_dirs[i].X, + BS / 2 * vertex_dirs[i].Y, + BS / 2 * vertex_dirs[i].Z ); } - for(u16 i=0; i<4; i++) - { - vertex_pos[i].X *= scale.X; - vertex_pos[i].Y *= scale.Y; - vertex_pos[i].Z *= scale.Z; - vertex_pos[i] += pos; + for (v3f &vpos : vertex_pos) { + vpos.X *= scale.X; + vpos.Y *= scale.Y; + vpos.Z *= scale.Z; + vpos += pos; } - f32 abs_scale = 1.0; - if (scale.X < 0.999 || scale.X > 1.001) abs_scale = scale.X; - else if(scale.Y < 0.999 || scale.Y > 1.001) abs_scale = scale.Y; - else if(scale.Z < 0.999 || scale.Z > 1.001) abs_scale = scale.Z; + f32 abs_scale = 1.0f; + if (scale.X < 0.999f || scale.X > 1.001f) abs_scale = scale.X; + else if (scale.Y < 0.999f || scale.Y > 1.001f) abs_scale = scale.Y; + else if (scale.Z < 0.999f || scale.Z > 1.001f) abs_scale = scale.Z; v3f normal(dir.X, dir.Y, dir.Z); - dest.push_back(FastFace()); + u16 li[4] = { li0, li1, li2, li3 }; + u16 day[4]; + u16 night[4]; - FastFace& face = *dest.rbegin(); + for (u8 i = 0; i < 4; i++) { + day[i] = li[i] >> 8; + night[i] = li[i] & 0xFF; + } + + bool vertex_0_2_connected = abs(day[0] - day[2]) + abs(night[0] - night[2]) + < abs(day[1] - day[3]) + abs(night[1] - night[3]); - u16 li[4] = { li0, li1, li2, li3 }; v2f32 f[4] = { core::vector2d(x0 + w * abs_scale, y0 + h), core::vector2d(x0, y0 + h), core::vector2d(x0, y0), core::vector2d(x0 + w * abs_scale, y0) }; - for (u8 i = 0; i < 4; i++) { - video::SColor c = encode_light_and_color(li[i], tile.color, - tile.emissive_light); - if (!tile.emissive_light) - applyFacesShading(c, normal); + for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++) { + const TileLayer *layer = &tile.layers[layernum]; + if (layer->texture_id == 0) + continue; - face.vertices[i] = video::S3DVertex(vertex_pos[i], normal, c, f[i]); - } + // equivalent to dest.push_back(FastFace()) but faster + dest.emplace_back(); + FastFace& face = *dest.rbegin(); + + for (u8 i = 0; i < 4; i++) { + video::SColor c = encode_light(li[i], tile.emissive_light); + if (!tile.emissive_light) + applyFacesShading(c, normal); - face.tile = tile; + face.vertices[i] = video::S3DVertex(vertex_pos[i], normal, c, f[i]); + } + + /* + Revert triangles for nicer looking gradient if the + brightness of vertices 1 and 3 differ less than + the brightness of vertices 0 and 2. + */ + face.vertex_0_2_connected = vertex_0_2_connected; + + face.layer = *layer; + face.layernum = layernum; + + face.world_aligned = tile.world_aligned; + } } /* @@ -617,73 +663,72 @@ static void makeFastFace(TileSpec tile, u16 li0, u16 li1, u16 li2, u16 li3, TODO: Add 3: Both faces drawn with backface culling, remove equivalent */ static u8 face_contents(content_t m1, content_t m2, bool *equivalent, - INodeDefManager *ndef) + const NodeDefManager *ndef) { *equivalent = false; - if(m1 == CONTENT_IGNORE || m2 == CONTENT_IGNORE) + if (m1 == m2 || m1 == CONTENT_IGNORE || m2 == CONTENT_IGNORE) return 0; - bool contents_differ = (m1 != m2); - const ContentFeatures &f1 = ndef->get(m1); const ContentFeatures &f2 = ndef->get(m2); // Contents don't differ for different forms of same liquid - if(f1.sameLiquid(f2)) - contents_differ = false; + if (f1.sameLiquid(f2)) + return 0; u8 c1 = f1.solidness; u8 c2 = f2.solidness; - bool solidness_differs = (c1 != c2); - bool makes_face = contents_differ && solidness_differs; - - if(makes_face == false) + if (c1 == c2) return 0; - if(c1 == 0) + if (c1 == 0) c1 = f1.visual_solidness; - if(c2 == 0) + else if (c2 == 0) c2 = f2.visual_solidness; - if(c1 == c2){ + if (c1 == c2) { *equivalent = true; // If same solidness, liquid takes precense - if(f1.isLiquid()) + if (f1.isLiquid()) return 1; - if(f2.isLiquid()) + if (f2.isLiquid()) return 2; } - if(c1 > c2) + if (c1 > c2) return 1; - else - return 2; + + return 2; } /* Gets nth node tile (0 <= n <= 5). */ -TileSpec getNodeTileN(MapNode mn, v3s16 p, u8 tileindex, MeshMakeData *data) +void getNodeTileN(MapNode mn, v3s16 p, u8 tileindex, MeshMakeData *data, TileSpec &tile) { - INodeDefManager *ndef = data->m_client->ndef(); + const NodeDefManager *ndef = data->m_client->ndef(); const ContentFeatures &f = ndef->get(mn); - TileSpec spec = f.tiles[tileindex]; - if (!spec.has_color) - mn.getColor(f, &spec.color); - // Apply temporary crack - if (p == data->m_crack_pos_relative) - spec.material_flags |= MATERIAL_FLAG_CRACK; - return spec; + tile = f.tiles[tileindex]; + bool has_crack = p == data->m_crack_pos_relative; + for (TileLayer &layer : tile.layers) { + if (layer.texture_id == 0) + continue; + if (!layer.has_color) + mn.getColor(f, &(layer.color)); + // Apply temporary crack + if (has_crack) + layer.material_flags |= MATERIAL_FLAG_CRACK; + } } /* Gets node tile given a face direction. */ -TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 dir, MeshMakeData *data) +void getNodeTile(MapNode mn, v3s16 p, v3s16 dir, MeshMakeData *data, TileSpec &tile) { - INodeDefManager *ndef = data->m_client->ndef(); + const NodeDefManager *ndef = data->m_client->ndef(); // Direction must be (1,0,0), (-1,0,0), (0,1,0), (0,-1,0), // (0,0,1), (0,0,-1) or (0,0,0) @@ -698,7 +743,7 @@ TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 dir, MeshMakeData *data) // 5 = (0,0,-1) // 6 = (0,-1,0) // 7 = (-1,0,0) - u8 dir_i = ((dir.X + 2 * dir.Y + 3 * dir.Z) & 7)*2; + u8 dir_i = ((dir.X + 2 * dir.Y + 3 * dir.Z) & 7) * 2; // Get rotation for things like chests u8 facedir = mn.getFaceDir(ndef); @@ -737,11 +782,9 @@ TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 dir, MeshMakeData *data) 0,0, 4,2 , 1,1 , 2,2 , 0,0, 3,2 , 0,3 , 5,2 }; - u16 tile_index=facedir*16 + dir_i; - TileSpec spec = getNodeTileN(mn, p, dir_to_tile[tile_index], data); - spec.rotation=dir_to_tile[tile_index + 1]; - spec.texture = data->m_client->tsrc()->getTexture(spec.texture_id); - return spec; + u16 tile_index = facedir * 16 + dir_i; + getNodeTileN(mn, p, dir_to_tile[tile_index], data, tile); + tile.rotation = tile.world_aligned ? 0 : dir_to_tile[tile_index + 1]; } static void getTileInfo( @@ -758,10 +801,10 @@ static void getTileInfo( ) { VoxelManipulator &vmanip = data->m_vmanip; - INodeDefManager *ndef = data->m_client->ndef(); + const NodeDefManager *ndef = data->m_client->ndef(); v3s16 blockpos_nodes = data->m_blockpos * MAP_BLOCKSIZE; - MapNode &n0 = vmanip.getNodeRefUnsafe(blockpos_nodes + p); + const MapNode &n0 = vmanip.getNodeRefUnsafe(blockpos_nodes + p); // Don't even try to get n1 if n0 is already CONTENT_IGNORE if (n0.getContent() == CONTENT_IGNORE) { @@ -769,8 +812,7 @@ static void getTileInfo( return; } - const MapNode &n1 = vmanip.getNodeRefUnsafeCheckFlags( - blockpos_nodes + p + face_dir); + const MapNode &n1 = vmanip.getNodeRefUnsafeCheckFlags(blockpos_nodes + p + face_dir); if (n1.getContent() == CONTENT_IGNORE) { makes_face = false; @@ -782,8 +824,7 @@ static void getTileInfo( u8 mf = face_contents(n0.getContent(), n1.getContent(), &equivalent, ndef); - if(mf == 0) - { + if (mf == 0) { makes_face = false; return; } @@ -800,32 +841,28 @@ static void getTileInfo( p_corrected = p + face_dir; face_dir_corrected = -face_dir; } - tile = getNodeTile(n, p_corrected, face_dir_corrected, data); + + getNodeTile(n, p_corrected, face_dir_corrected, data, tile); const ContentFeatures &f = ndef->get(n); tile.emissive_light = f.light_source; // eg. water and glass - if (equivalent) - tile.material_flags |= MATERIAL_FLAG_BACKFACE_CULLING; + if (equivalent) { + for (TileLayer &layer : tile.layers) + layer.material_flags |= MATERIAL_FLAG_BACKFACE_CULLING; + } - if (data->m_smooth_lighting == false) - { + if (!data->m_smooth_lighting) { lights[0] = lights[1] = lights[2] = lights[3] = getFaceLight(n0, n1, face_dir, ndef); - } - else - { + } else { v3s16 vertex_dirs[4]; getNodeVertexDirs(face_dir_corrected, vertex_dirs); - for(u16 i=0; i<4; i++) - { - lights[i] = getSmoothLight( - blockpos_nodes + p_corrected, - vertex_dirs[i], data); - } - } - return; + v3s16 light_p = blockpos_nodes + p_corrected; + for (u16 i = 0; i < 4; i++) + lights[i] = getSmoothLightSolid(light_p, face_dir_corrected, vertex_dirs[i], data); + } } /* @@ -835,11 +872,10 @@ static void getTileInfo( */ static void updateFastFaceRow( MeshMakeData *data, - v3s16 startpos, + const v3s16 &&startpos, v3s16 translate_dir, - v3f translate_dir_f, - v3s16 face_dir, - v3f face_dir_f, + const v3f &&translate_dir_f, + const v3s16 &&face_dir, std::vector &dest) { v3s16 p = startpos; @@ -849,14 +885,15 @@ static void updateFastFaceRow( bool makes_face = false; v3s16 p_corrected; v3s16 face_dir_corrected; - u16 lights[4] = {0,0,0,0}; + u16 lights[4] = {0, 0, 0, 0}; TileSpec tile; getTileInfo(data, p, face_dir, makes_face, p_corrected, face_dir_corrected, lights, tile); - for(u16 j=0; jadd("Meshgen: diff: next_makes_face != makes_face", - next_makes_face != makes_face ? 1 : 0); - g_profiler->add("Meshgen: diff: n_p_corr != p_corr + t_dir", - (next_p_corrected != p_corrected + translate_dir) ? 1 : 0); - g_profiler->add("Meshgen: diff: next_f_dir_corr != f_dir_corr", - next_face_dir_corrected != face_dir_corrected ? 1 : 0); - g_profiler->add("Meshgen: diff: next_lights[] != lights[]", - (next_lights[0] != lights[0] || - next_lights[0] != lights[0] || - next_lights[0] != lights[0] || - next_lights[0] != lights[0]) ? 1 : 0); - g_profiler->add("Meshgen: diff: !(next_tile == tile)", - !(next_tile == tile) ? 1 : 0); - }*/ } - /*g_profiler->add("Meshgen: Total faces checked", 1); - if(makes_face) - g_profiler->add("Meshgen: Total makes_face checked", 1);*/ - } else { - /*if(makes_face) - g_profiler->add("Meshgen: diff: last position", 1);*/ } - - if(next_is_different) - { + if (next_is_different) { /* Create a face if there should be one */ - if(makes_face) - { + if (makes_face) { // Floating point conversion of the position vector v3f pf(p_corrected.X, p_corrected.Y, p_corrected.Z); // Center point of face (kind of) - v3f sp = pf - ((f32)continuous_tiles_count / 2.0 - 0.5) * translate_dir_f; - v3f scale(1,1,1); + v3f sp = pf - ((f32)continuous_tiles_count * 0.5f - 0.5f) + * translate_dir_f; + v3f scale(1, 1, 1); - if(translate_dir.X != 0) { + if (translate_dir.X != 0) scale.X = continuous_tiles_count; - } - if(translate_dir.Y != 0) { + if (translate_dir.Y != 0) scale.Y = continuous_tiles_count; - } - if(translate_dir.Z != 0) { + if (translate_dir.Z != 0) scale.Z = continuous_tiles_count; - } makeFastFace(tile, lights[0], lights[1], lights[2], lights[3], - sp, face_dir_corrected, scale, dest); + pf, sp, face_dir_corrected, scale, dest); g_profiler->avg("Meshgen: faces drawn by tiling", 0); - for(int i = 1; i < continuous_tiles_count; i++){ + for (int i = 1; i < continuous_tiles_count; i++) g_profiler->avg("Meshgen: faces drawn by tiling", 1); - } } continuous_tiles_count = 1; @@ -957,11 +956,9 @@ static void updateFastFaceRow( makes_face = next_makes_face; p_corrected = next_p_corrected; face_dir_corrected = next_face_dir_corrected; - lights[0] = next_lights[0]; - lights[1] = next_lights[1]; - lights[2] = next_lights[2]; - lights[3] = next_lights[3]; - tile = next_tile; + std::memcpy(lights, next_lights, ARRLEN(lights) * sizeof(u16)); + if (next_is_different) + tile = next_tile; p = p_next; } } @@ -972,47 +969,38 @@ static void updateAllFastFaceRows(MeshMakeData *data, /* Go through every y,z and get top(y+) faces in rows of x+ */ - for(s16 y = 0; y < MAP_BLOCKSIZE; y++) { - for(s16 z = 0; z < MAP_BLOCKSIZE; z++) { - updateFastFaceRow(data, - v3s16(0,y,z), - v3s16(1,0,0), //dir - v3f (1,0,0), - v3s16(0,1,0), //face dir - v3f (0,1,0), - dest); - } - } + for (s16 y = 0; y < MAP_BLOCKSIZE; y++) + for (s16 z = 0; z < MAP_BLOCKSIZE; z++) + updateFastFaceRow(data, + v3s16(0, y, z), + v3s16(1, 0, 0), //dir + v3f (1, 0, 0), + v3s16(0, 1, 0), //face dir + dest); /* Go through every x,y and get right(x+) faces in rows of z+ */ - for(s16 x = 0; x < MAP_BLOCKSIZE; x++) { - for(s16 y = 0; y < MAP_BLOCKSIZE; y++) { - updateFastFaceRow(data, - v3s16(x,y,0), - v3s16(0,0,1), //dir - v3f (0,0,1), - v3s16(1,0,0), //face dir - v3f (1,0,0), - dest); - } - } + for (s16 x = 0; x < MAP_BLOCKSIZE; x++) + for (s16 y = 0; y < MAP_BLOCKSIZE; y++) + updateFastFaceRow(data, + v3s16(x, y, 0), + v3s16(0, 0, 1), //dir + v3f (0, 0, 1), + v3s16(1, 0, 0), //face dir + dest); /* Go through every y,z and get back(z+) faces in rows of x+ */ - for(s16 z = 0; z < MAP_BLOCKSIZE; z++) { - for(s16 y = 0; y < MAP_BLOCKSIZE; y++) { - updateFastFaceRow(data, - v3s16(0,y,z), - v3s16(1,0,0), //dir - v3f (1,0,0), - v3s16(0,0,1), //face dir - v3f (0,0,1), - dest); - } - } + for (s16 z = 0; z < MAP_BLOCKSIZE; z++) + for (s16 y = 0; y < MAP_BLOCKSIZE; y++) + updateFastFaceRow(data, + v3s16(0, y, z), + v3s16(1, 0, 0), //dir + v3f (1, 0, 0), + v3s16(0, 0, 1), //face dir + dest); } /* @@ -1020,18 +1008,15 @@ static void updateAllFastFaceRows(MeshMakeData *data, */ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset): - m_mesh(new scene::SMesh()), m_minimap_mapblock(NULL), - m_client(data->m_client), - m_driver(m_client->tsrc()->getDevice()->getVideoDriver()), - m_tsrc(m_client->getTextureSource()), - m_shdrsrc(m_client->getShaderSource()), + m_tsrc(data->m_client->getTextureSource()), + m_shdrsrc(data->m_client->getShaderSource()), m_animation_force_timer(0), // force initial animation m_last_crack(-1), - m_crack_materials(), - m_last_daynight_ratio((u32) -1), - m_daynight_diffs() + m_last_daynight_ratio((u32) -1) { + for (auto &m : m_mesh) + m = new scene::SMesh(); m_enable_shaders = data->m_use_shaders; m_use_tangent_vertices = data->m_use_tangent_vertices; m_enable_vbo = g_settings->getBool("enable_vbo"); @@ -1074,29 +1059,18 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset): // (NOTE: probably outdated) //TimeTaker timer2("MeshCollector building"); - for (u32 i = 0; i < fastfaces_new.size(); i++) { - FastFace &f = fastfaces_new[i]; + for (const FastFace &f : fastfaces_new) { + static const u16 indices[] = {0, 1, 2, 2, 3, 0}; + static const u16 indices_alternate[] = {0, 1, 3, 2, 3, 1}; - const u16 indices[] = {0,1,2,2,3,0}; - const u16 indices_alternate[] = {0,1,3,2,3,1}; - - if(f.tile.texture == NULL) + if (!f.layer.texture) continue; - const u16 *indices_p = indices; + const u16 *indices_p = + f.vertex_0_2_connected ? indices : indices_alternate; - /* - Revert triangles for nicer looking gradient if the - brightness of vertices 1 and 3 differ less than - the brightness of vertices 0 and 2. - */ - if (fabs(f.vertices[0].Color.getLuminance() - - f.vertices[2].Color.getLuminance()) - > fabs(f.vertices[1].Color.getLuminance() - - f.vertices[3].Color.getLuminance())) - indices_p = indices_alternate; - - collector.append(f.tile, f.vertices, 4, indices_p, 6); + collector.append(f.layer, f.vertices, 4, indices_p, 6, + f.layernum, f.world_aligned); } } @@ -1113,146 +1087,152 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset): generator.generate(); } + collector.applyTileColors(); + /* Convert MeshCollector to SMesh */ - for(u32 i = 0; i < collector.prebuffers.size(); i++) - { - PreMeshBuffer &p = collector.prebuffers[i]; - - // Generate animation data - // - Cracks - if(p.tile.material_flags & MATERIAL_FLAG_CRACK) + for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) { + for(u32 i = 0; i < collector.prebuffers[layer].size(); i++) { - // Find the texture name plus ^[crack:N: - std::ostringstream os(std::ios::binary); - os<getTextureName(p.tile.texture_id)<<"^[crack"; - if(p.tile.material_flags & MATERIAL_FLAG_CRACK_OVERLAY) - os<<"o"; // use ^[cracko - os<<":"<<(u32)p.tile.animation_frame_count<<":"; - m_crack_materials.insert(std::make_pair(i, os.str())); - // Replace tile texture with the cracked one - p.tile.texture = m_tsrc->getTextureForMesh( - os.str()+"0", - &p.tile.texture_id); - } - // - Texture animation - if (p.tile.material_flags & MATERIAL_FLAG_ANIMATION) { - // Add to MapBlockMesh in order to animate these tiles - m_animation_tiles[i] = p.tile; - m_animation_frames[i] = 0; - if(g_settings->getBool("desynchronize_mapblock_texture_animation")){ - // Get starting position from noise - m_animation_frame_offsets[i] = 100000 * (2.0 + noise3d( - data->m_blockpos.X, data->m_blockpos.Y, - data->m_blockpos.Z, 0)); - } else { - // Play all synchronized - m_animation_frame_offsets[i] = 0; + PreMeshBuffer &p = collector.prebuffers[layer][i]; + + // Generate animation data + // - Cracks + if (p.layer.material_flags & MATERIAL_FLAG_CRACK) { + // Find the texture name plus ^[crack:N: + std::ostringstream os(std::ios::binary); + os << m_tsrc->getTextureName(p.layer.texture_id) << "^[crack"; + if (p.layer.material_flags & MATERIAL_FLAG_CRACK_OVERLAY) + os << "o"; // use ^[cracko + u8 tiles = p.layer.scale; + if (tiles > 1) + os << ":" << (u32)tiles; + os << ":" << (u32)p.layer.animation_frame_count << ":"; + m_crack_materials.insert(std::make_pair( + std::pair(layer, i), os.str())); + // Replace tile texture with the cracked one + p.layer.texture = m_tsrc->getTextureForMesh( + os.str() + "0", + &p.layer.texture_id); } - // Replace tile texture with the first animation frame - FrameSpec animation_frame = p.tile.frames[0]; - p.tile.texture = animation_frame.texture; - } - - if (!m_enable_shaders) { - // Extract colors for day-night animation - // Dummy sunlight to handle non-sunlit areas - video::SColorf sunlight; - get_sunlight_color(&sunlight, 0); - u32 vertex_count = - m_use_tangent_vertices ? - p.tangent_vertices.size() : p.vertices.size(); - for (u32 j = 0; j < vertex_count; j++) { - video::SColor *vc; - if (m_use_tangent_vertices) { - vc = &p.tangent_vertices[j].Color; + // - Texture animation + if (p.layer.material_flags & MATERIAL_FLAG_ANIMATION) { + // Add to MapBlockMesh in order to animate these tiles + m_animation_tiles[std::pair(layer, i)] = p.layer; + m_animation_frames[std::pair(layer, i)] = 0; + if (g_settings->getBool( + "desynchronize_mapblock_texture_animation")) { + // Get starting position from noise + m_animation_frame_offsets[std::pair(layer, i)] = + 100000 * (2.0 + noise3d( + data->m_blockpos.X, data->m_blockpos.Y, + data->m_blockpos.Z, 0)); } else { - vc = &p.vertices[j].Color; + // Play all synchronized + m_animation_frame_offsets[std::pair(layer, i)] = 0; } - video::SColor copy(*vc); - if (vc->getAlpha() == 0) // No sunlight - no need to animate - final_color_blend(vc, copy, sunlight); // Finalize color - else // Record color to animate - m_daynight_diffs[i][j] = copy; - - // The sunlight ratio has been stored, - // delete alpha (for the final rendering). - vc->setAlpha(255); + // Replace tile texture with the first animation frame + p.layer.texture = (*p.layer.frames)[0].texture; } - } - // Create material - video::SMaterial material; - material.setFlag(video::EMF_LIGHTING, false); - material.setFlag(video::EMF_BACK_FACE_CULLING, true); - material.setFlag(video::EMF_BILINEAR_FILTER, false); - material.setFlag(video::EMF_FOG_ENABLE, true); - material.setTexture(0, p.tile.texture); + if (!m_enable_shaders) { + // Extract colors for day-night animation + // Dummy sunlight to handle non-sunlit areas + video::SColorf sunlight; + get_sunlight_color(&sunlight, 0); + u32 vertex_count = m_use_tangent_vertices ? + p.tangent_vertices.size() : p.vertices.size(); + for (u32 j = 0; j < vertex_count; j++) { + video::SColor *vc; + if (m_use_tangent_vertices) { + vc = &p.tangent_vertices[j].Color; + } else { + vc = &p.vertices[j].Color; + } + video::SColor copy(*vc); + if (vc->getAlpha() == 0) // No sunlight - no need to animate + final_color_blend(vc, copy, sunlight); // Finalize color + else // Record color to animate + m_daynight_diffs[std::pair(layer, i)][j] = copy; + + // The sunlight ratio has been stored, + // delete alpha (for the final rendering). + vc->setAlpha(255); + } + } - if (m_enable_shaders) { - material.MaterialType = m_shdrsrc->getShaderInfo(p.tile.shader_id).material; - p.tile.applyMaterialOptionsWithShaders(material); - if (p.tile.normal_texture) { - material.setTexture(1, p.tile.normal_texture); + // Create material + video::SMaterial material; + material.setFlag(video::EMF_LIGHTING, false); + material.setFlag(video::EMF_BACK_FACE_CULLING, true); + material.setFlag(video::EMF_BILINEAR_FILTER, false); + material.setFlag(video::EMF_FOG_ENABLE, true); + material.setTexture(0, p.layer.texture); + + if (m_enable_shaders) { + material.MaterialType = m_shdrsrc->getShaderInfo( + p.layer.shader_id).material; + p.layer.applyMaterialOptionsWithShaders(material); + if (p.layer.normal_texture) + material.setTexture(1, p.layer.normal_texture); + material.setTexture(2, p.layer.flags_texture); + } else { + p.layer.applyMaterialOptions(material); + } + + scene::SMesh *mesh = (scene::SMesh *)m_mesh[layer]; + + // Create meshbuffer, add to mesh + if (m_use_tangent_vertices) { + scene::SMeshBufferTangents *buf = + new scene::SMeshBufferTangents(); + // Set material + buf->Material = material; + // Add to mesh + mesh->addMeshBuffer(buf); + // Mesh grabbed it + buf->drop(); + buf->append(&p.tangent_vertices[0], p.tangent_vertices.size(), + &p.indices[0], p.indices.size()); + } else { + scene::SMeshBuffer *buf = new scene::SMeshBuffer(); + // Set material + buf->Material = material; + // Add to mesh + mesh->addMeshBuffer(buf); + // Mesh grabbed it + buf->drop(); + buf->append(&p.vertices[0], p.vertices.size(), + &p.indices[0], p.indices.size()); } - material.setTexture(2, p.tile.flags_texture); - } else { - p.tile.applyMaterialOptions(material); } - scene::SMesh *mesh = (scene::SMesh *)m_mesh; + /* + Do some stuff to the mesh + */ + m_camera_offset = camera_offset; + translateMesh(m_mesh[layer], + intToFloat(data->m_blockpos * MAP_BLOCKSIZE - camera_offset, BS)); - // Create meshbuffer, add to mesh if (m_use_tangent_vertices) { - scene::SMeshBufferTangents *buf = new scene::SMeshBufferTangents(); - // Set material - buf->Material = material; - // Add to mesh - mesh->addMeshBuffer(buf); - // Mesh grabbed it - buf->drop(); - buf->append(&p.tangent_vertices[0], p.tangent_vertices.size(), - &p.indices[0], p.indices.size()); - } else { - scene::SMeshBuffer *buf = new scene::SMeshBuffer(); - // Set material - buf->Material = material; - // Add to mesh - mesh->addMeshBuffer(buf); - // Mesh grabbed it - buf->drop(); - buf->append(&p.vertices[0], p.vertices.size(), - &p.indices[0], p.indices.size()); + scene::IMeshManipulator* meshmanip = + RenderingEngine::get_scene_manager()->getMeshManipulator(); + meshmanip->recalculateTangents(m_mesh[layer], true, false, false); } - } - - /* - Do some stuff to the mesh - */ - m_camera_offset = camera_offset; - translateMesh(m_mesh, - intToFloat(data->m_blockpos * MAP_BLOCKSIZE - camera_offset, BS)); - if (m_use_tangent_vertices) { - scene::IMeshManipulator* meshmanip = - m_client->getSceneManager()->getMeshManipulator(); - meshmanip->recalculateTangents(m_mesh, true, false, false); - } - - if (m_mesh) - { + if (m_mesh[layer]) { #if 0 - // Usually 1-700 faces and 1-7 materials - std::cout<<"Updated MapBlock has "<getMeshBufferCount() - <<" materials (meshbuffers)"<getMeshBufferCount() + << " materials (meshbuffers)" << std::endl; #endif - // Use VBO for mesh (this just would set this for ever buffer) - if (m_enable_vbo) { - m_mesh->setHardwareMappingHint(scene::EHM_STATIC); + // Use VBO for mesh (this just would set this for ever buffer) + if (m_enable_vbo) + m_mesh[layer]->setHardwareMappingHint(scene::EHM_STATIC); } } @@ -1267,21 +1247,22 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset): MapBlockMesh::~MapBlockMesh() { - if (m_enable_vbo && m_mesh) { - for (u32 i = 0; i < m_mesh->getMeshBufferCount(); i++) { - scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i); - m_driver->removeHardwareBuffer(buf); - } + for (scene::IMesh *m : m_mesh) { + if (m_enable_vbo && m) + for (u32 i = 0; i < m->getMeshBufferCount(); i++) { + scene::IMeshBuffer *buf = m->getMeshBuffer(i); + RenderingEngine::get_video_driver()->removeHardwareBuffer(buf); + } + m->drop(); + m = NULL; } - m_mesh->drop(); - m_mesh = NULL; delete m_minimap_mapblock; } -bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_ratio) +bool MapBlockMesh::animate(bool faraway, float time, int crack, + u32 daynight_ratio) { - if(!m_has_animation) - { + if (!m_has_animation) { m_animation_force_timer = 100000; return false; } @@ -1289,31 +1270,29 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat m_animation_force_timer = myrand_range(5, 100); // Cracks - if(crack != m_last_crack) - { - for (UNORDERED_MAP::iterator i = m_crack_materials.begin(); - i != m_crack_materials.end(); ++i) { - scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first); - std::string basename = i->second; + if (crack != m_last_crack) { + for (auto &crack_material : m_crack_materials) { + scene::IMeshBuffer *buf = m_mesh[crack_material.first.first]-> + getMeshBuffer(crack_material.first.second); + std::string basename = crack_material.second; // Create new texture name from original std::ostringstream os; - os<getTextureForMesh(os.str(), &new_texture_id); + m_tsrc->getTextureForMesh(os.str(), &new_texture_id); buf->getMaterial().setTexture(0, new_texture); // If the current material is also animated, // update animation info - UNORDERED_MAP::iterator anim_iter = - m_animation_tiles.find(i->first); - if (anim_iter != m_animation_tiles.end()){ - TileSpec &tile = anim_iter->second; + auto anim_iter = m_animation_tiles.find(crack_material.first); + if (anim_iter != m_animation_tiles.end()) { + TileLayer &tile = anim_iter->second; tile.texture = new_texture; tile.texture_id = new_texture_id; // force animation update - m_animation_frames[i->first] = -1; + m_animation_frames[crack_material.first] = -1; } } @@ -1321,52 +1300,47 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat } // Texture animation - for (UNORDERED_MAP::iterator i = m_animation_tiles.begin(); - i != m_animation_tiles.end(); ++i) { - const TileSpec &tile = i->second; + for (auto &animation_tile : m_animation_tiles) { + const TileLayer &tile = animation_tile.second; // Figure out current frame - int frameoffset = m_animation_frame_offsets[i->first]; + int frameoffset = m_animation_frame_offsets[animation_tile.first]; int frame = (int)(time * 1000 / tile.animation_frame_length_ms + frameoffset) % tile.animation_frame_count; // If frame doesn't change, skip - if(frame == m_animation_frames[i->first]) + if (frame == m_animation_frames[animation_tile.first]) continue; - m_animation_frames[i->first] = frame; + m_animation_frames[animation_tile.first] = frame; - scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first); + scene::IMeshBuffer *buf = m_mesh[animation_tile.first.first]-> + getMeshBuffer(animation_tile.first.second); - FrameSpec animation_frame = tile.frames[frame]; + const FrameSpec &animation_frame = (*tile.frames)[frame]; buf->getMaterial().setTexture(0, animation_frame.texture); if (m_enable_shaders) { - if (animation_frame.normal_texture) { - buf->getMaterial().setTexture(1, animation_frame.normal_texture); - } + if (animation_frame.normal_texture) + buf->getMaterial().setTexture(1, + animation_frame.normal_texture); buf->getMaterial().setTexture(2, animation_frame.flags_texture); } } // Day-night transition - if(!m_enable_shaders && (daynight_ratio != m_last_daynight_ratio)) - { + if (!m_enable_shaders && (daynight_ratio != m_last_daynight_ratio)) { // Force reload mesh to VBO - if (m_enable_vbo) { - m_mesh->setDirty(); - } + if (m_enable_vbo) + for (scene::IMesh *m : m_mesh) + m->setDirty(); video::SColorf day_color; get_sunlight_color(&day_color, daynight_ratio); - for(std::map >::iterator - i = m_daynight_diffs.begin(); - i != m_daynight_diffs.end(); ++i) - { - scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first); + + for (auto &daynight_diff : m_daynight_diffs) { + scene::IMeshBuffer *buf = m_mesh[daynight_diff.first.first]-> + getMeshBuffer(daynight_diff.first.second); video::S3DVertex *vertices = (video::S3DVertex *)buf->getVertices(); - for(std::map::iterator - j = i->second.begin(); - j != i->second.end(); ++j) - { - final_color_blend(&(vertices[j->first].Color), j->second, day_color); - } + for (const auto &j : daynight_diff.second) + final_color_blend(&(vertices[j.first].Color), j.second, + day_color); } m_last_daynight_ratio = daynight_ratio; } @@ -1377,9 +1351,11 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat void MapBlockMesh::updateCameraOffset(v3s16 camera_offset) { if (camera_offset != m_camera_offset) { - translateMesh(m_mesh, intToFloat(m_camera_offset-camera_offset, BS)); - if (m_enable_vbo) { - m_mesh->setDirty(); + for (scene::IMesh *layer : m_mesh) { + translateMesh(layer, + intToFloat(m_camera_offset - camera_offset, BS)); + if (m_enable_vbo) + layer->setDirty(); } m_camera_offset = camera_offset; } @@ -1392,44 +1368,62 @@ void MapBlockMesh::updateCameraOffset(v3s16 camera_offset) void MeshCollector::append(const TileSpec &tile, const video::S3DVertex *vertices, u32 numVertices, const u16 *indices, u32 numIndices) +{ + for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++) { + const TileLayer *layer = &tile.layers[layernum]; + if (layer->texture_id == 0) + continue; + append(*layer, vertices, numVertices, indices, numIndices, + layernum, tile.world_aligned); + } +} + +void MeshCollector::append(const TileLayer &layer, + const video::S3DVertex *vertices, u32 numVertices, + const u16 *indices, u32 numIndices, u8 layernum, + bool use_scale) { if (numIndices > 65535) { - dstream<<"FIXME: MeshCollector::append() called with numIndices="< *buffers = &prebuffers[layernum]; PreMeshBuffer *p = NULL; - for (u32 i = 0; i < prebuffers.size(); i++) { - PreMeshBuffer &pp = prebuffers[i]; - if (pp.tile != tile) - continue; - if (pp.indices.size() + numIndices > 65535) - continue; - - p = &pp; - break; + for (PreMeshBuffer &pp : *buffers) { + if (pp.layer == layer && pp.indices.size() + numIndices <= 65535) { + p = &pp; + break; + } } if (p == NULL) { PreMeshBuffer pp; - pp.tile = tile; - prebuffers.push_back(pp); - p = &prebuffers[prebuffers.size() - 1]; + pp.layer = layer; + buffers->push_back(pp); + p = &(*buffers)[buffers->size() - 1]; } + f32 scale = 1.0; + if (use_scale) + scale = 1.0 / layer.scale; + u32 vertex_count; if (m_use_tangent_vertices) { vertex_count = p->tangent_vertices.size(); for (u32 i = 0; i < numVertices; i++) { + video::S3DVertexTangents vert(vertices[i].Pos, vertices[i].Normal, - vertices[i].Color, vertices[i].TCoords); + vertices[i].Color, scale * vertices[i].TCoords); p->tangent_vertices.push_back(vert); } } else { vertex_count = p->vertices.size(); for (u32 i = 0; i < numVertices; i++) { video::S3DVertex vert(vertices[i].Pos, vertices[i].Normal, - vertices[i].Color, vertices[i].TCoords); + vertices[i].Color, scale * vertices[i].TCoords); + p->vertices.push_back(vert); } } @@ -1448,31 +1442,48 @@ void MeshCollector::append(const TileSpec &tile, const video::S3DVertex *vertices, u32 numVertices, const u16 *indices, u32 numIndices, v3f pos, video::SColor c, u8 light_source) +{ + for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++) { + const TileLayer *layer = &tile.layers[layernum]; + if (layer->texture_id == 0) + continue; + append(*layer, vertices, numVertices, indices, numIndices, pos, + c, light_source, layernum, tile.world_aligned); + } +} + +void MeshCollector::append(const TileLayer &layer, + const video::S3DVertex *vertices, u32 numVertices, + const u16 *indices, u32 numIndices, + v3f pos, video::SColor c, u8 light_source, u8 layernum, + bool use_scale) { if (numIndices > 65535) { - dstream<<"FIXME: MeshCollector::append() called with numIndices="< *buffers = &prebuffers[layernum]; PreMeshBuffer *p = NULL; - for (u32 i = 0; i < prebuffers.size(); i++) { - PreMeshBuffer &pp = prebuffers[i]; - if(pp.tile != tile) - continue; - if(pp.indices.size() + numIndices > 65535) - continue; - - p = &pp; - break; + for (PreMeshBuffer &pp : *buffers) { + if (pp.layer == layer && pp.indices.size() + numIndices <= 65535) { + p = &pp; + break; + } } if (p == NULL) { PreMeshBuffer pp; - pp.tile = tile; - prebuffers.push_back(pp); - p = &prebuffers[prebuffers.size() - 1]; + pp.layer = layer; + buffers->push_back(pp); + p = &(*buffers)[buffers->size() - 1]; } + f32 scale = 1.0; + if (use_scale) + scale = 1.0 / layer.scale; + video::SColor original_c = c; u32 vertex_count; if (m_use_tangent_vertices) { @@ -1483,7 +1494,7 @@ void MeshCollector::append(const TileSpec &tile, applyFacesShading(c, vertices[i].Normal); } video::S3DVertexTangents vert(vertices[i].Pos + pos, - vertices[i].Normal, c, vertices[i].TCoords); + vertices[i].Normal, c, scale * vertices[i].TCoords); p->tangent_vertices.push_back(vert); } } else { @@ -1494,7 +1505,7 @@ void MeshCollector::append(const TileSpec &tile, applyFacesShading(c, vertices[i].Normal); } video::S3DVertex vert(vertices[i].Pos + pos, vertices[i].Normal, c, - vertices[i].TCoords); + scale * vertices[i].TCoords); p->vertices.push_back(vert); } } @@ -1505,14 +1516,45 @@ void MeshCollector::append(const TileSpec &tile, } } -video::SColor encode_light_and_color(u16 light, const video::SColor &color, - u8 emissive_light) +void MeshCollector::applyTileColors() +{ + if (m_use_tangent_vertices) + for (auto &prebuffer : prebuffers) { + for (PreMeshBuffer &pmb : prebuffer) { + video::SColor tc = pmb.layer.color; + if (tc == video::SColor(0xFFFFFFFF)) + continue; + for (video::S3DVertexTangents &tangent_vertex : pmb.tangent_vertices) { + video::SColor *c = &tangent_vertex.Color; + c->set(c->getAlpha(), c->getRed() * tc.getRed() / 255, + c->getGreen() * tc.getGreen() / 255, + c->getBlue() * tc.getBlue() / 255); + } + } + } + else + for (auto &prebuffer : prebuffers) { + for (PreMeshBuffer &pmb : prebuffer) { + video::SColor tc = pmb.layer.color; + if (tc == video::SColor(0xFFFFFFFF)) + continue; + for (video::S3DVertex &vertex : pmb.vertices) { + video::SColor *c = &vertex.Color; + c->set(c->getAlpha(), c->getRed() * tc.getRed() / 255, + c->getGreen() * tc.getGreen() / 255, + c->getBlue() * tc.getBlue() / 255); + } + } + } +} + +video::SColor encode_light(u16 light, u8 emissive_light) { // Get components - f32 day = (light & 0xff) / 255.0f; - f32 night = (light >> 8) / 255.0f; + u32 day = (light & 0xff); + u32 night = (light >> 8); // Add emissive light - night += emissive_light * 0.01f; + night += emissive_light * 2.5f; if (night > 255) night = 255; // Since we don't know if the day light is sunlight or @@ -1522,15 +1564,14 @@ video::SColor encode_light_and_color(u16 light, const video::SColor &color, day = 0; else day = day - night; - f32 sum = day + night; + u32 sum = day + night; // Ratio of sunlight: - float r; + u32 r; if (sum > 0) - r = day / sum; + r = day * 255 / sum; else r = 0; // Average light: float b = (day + night) / 2; - return video::SColor(r * 255, b * color.getRed(), b * color.getGreen(), - b * color.getBlue()); + return video::SColor(r, b, b, b); }