X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapblock_mesh.cpp;h=e854127c0b4d8725a682c05c0009788db61ac430;hb=9a17b65f26eea5b9d7176e7df205f72ed2ff6c0f;hp=a928b82ff764c24c4f3d2ca446affba3d28ac735;hpb=6b598f61a6920823aad7c8814bad8e68f85ad66b;p=minetest.git diff --git a/src/mapblock_mesh.cpp b/src/mapblock_mesh.cpp index a928b82ff..e854127c0 100644 --- a/src/mapblock_mesh.cpp +++ b/src/mapblock_mesh.cpp @@ -1,6 +1,6 @@ /* -Minetest-c55 -Copyright (C) 2010-2011 celeron55, Perttu Ahola +Minetest +Copyright (C) 2010-2013 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by @@ -21,76 +21,72 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "light.h" #include "mapblock.h" #include "map.h" -#include "main.h" // for g_profiler #include "profiler.h" #include "nodedef.h" -#include "gamedef.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 "client/renderingengine.h" /* MeshMakeData */ -MeshMakeData::MeshMakeData(IGameDef *gamedef): - m_vmanip(), - m_blockpos(-1337,-1337,-1337), - m_crack_pos_relative(-1337, -1337, -1337), - m_smooth_lighting(false), - m_gamedef(gamedef) +MeshMakeData::MeshMakeData(Client *client, bool use_shaders, + bool use_tangent_vertices): + 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(); - m_vmanip.addArea(VoxelArea(blockpos_nodes-v3s16(1,1,1)*MAP_BLOCKSIZE, - blockpos_nodes+v3s16(1,1,1)*MAP_BLOCKSIZE*2-v3s16(1,1,1))); + 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. - */ - - // Get map - Map *map = block->getParent(); +void MeshMakeData::fill(MapBlock *block) +{ + fillBlockDataBegin(block->getPos()); - for(u16 i=0; i<6; i++) - { - const v3s16 &dir = g_6dirs[i]; - v3s16 bp = m_blockpos + dir; - MapBlock *b = map->getBlockNoCreateNoEx(bp); - if(b) - b->copyTo(m_vmanip); - } + fillBlockData(v3s16(0,0,0), block->getData()); + + // Get map for reading neigbhor blocks + Map *map = block->getParent(); + + 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) + fillBlockData(dir, b->getData()); } } void MeshMakeData::fillSingleNode(MapNode *node) { m_blockpos = v3s16(0,0,0); - + v3s16 blockpos_nodes = v3s16(0,0,0); VoxelArea area(blockpos_nodes-v3s16(1,1,1)*MAP_BLOCKSIZE, blockpos_nodes+v3s16(1,1,1)*MAP_BLOCKSIZE*2-v3s16(1,1,1)); @@ -138,9 +134,8 @@ void MeshMakeData::setSmoothLighting(bool smooth_lighting) Single light bank. */ static u8 getInteriorLight(enum LightBank bank, MapNode n, s32 increment, - MeshMakeData *data) + INodeDefManager *ndef) { - INodeDefManager *ndef = data->m_gamedef->ndef(); u8 light = n.getLight(bank, ndef); while(increment > 0) @@ -161,10 +156,10 @@ 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, MeshMakeData *data) +u16 getInteriorLight(MapNode n, s32 increment, INodeDefManager *ndef) { - u16 day = getInteriorLight(LIGHTBANK_DAY, n, increment, data); - u16 night = getInteriorLight(LIGHTBANK_NIGHT, n, increment, data); + u16 day = getInteriorLight(LIGHTBANK_DAY, n, increment, ndef); + u16 night = getInteriorLight(LIGHTBANK_NIGHT, n, increment, ndef); return day | (night << 8); } @@ -173,10 +168,8 @@ u16 getInteriorLight(MapNode n, s32 increment, MeshMakeData *data) Single light bank. */ static u8 getFaceLight(enum LightBank bank, MapNode n, MapNode n2, - v3s16 face_dir, MeshMakeData *data) + v3s16 face_dir, INodeDefManager *ndef) { - INodeDefManager *ndef = data->m_gamedef->ndef(); - u8 light; u8 l1 = n.getLight(bank, ndef); u8 l2 = n2.getLight(bank, ndef); @@ -188,26 +181,9 @@ static u8 getFaceLight(enum LightBank bank, MapNode n, MapNode n2, // Boost light level for light sources u8 light_source = MYMAX(ndef->get(n).light_source, ndef->get(n2).light_source); - //if(light_source >= light) - //return decode_light(undiminish_light(light_source)); if(light_source > light) - //return decode_light(light_source); light = light_source; - // Make some nice difference to different sides - - // This makes light come from a corner - /*if(face_dir.X == 1 || face_dir.Z == 1 || face_dir.Y == -1) - light = diminish_light(diminish_light(light)); - else if(face_dir.X == -1 || face_dir.Z == -1) - light = diminish_light(light);*/ - - // All neighboring faces have different shade (like in minecraft) - if(face_dir.X == 1 || face_dir.X == -1 || face_dir.Y == -1) - light = diminish_light(diminish_light(light)); - else if(face_dir.Z == 1 || face_dir.Z == -1) - light = diminish_light(light); - return decode_light(light); } @@ -215,20 +191,20 @@ 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, MeshMakeData *data) +u16 getFaceLight(MapNode n, MapNode n2, v3s16 face_dir, INodeDefManager *ndef) { - u16 day = getFaceLight(LIGHTBANK_DAY, n, n2, face_dir, data); - u16 night = getFaceLight(LIGHTBANK_NIGHT, n, n2, face_dir, data); + u16 day = getFaceLight(LIGHTBANK_DAY, n, n2, face_dir, ndef); + u16 night = getFaceLight(LIGHTBANK_NIGHT, n, n2, face_dir, ndef); return day | (night << 8); } /* Calculate smooth lighting at the XYZ- corner of p. - Single light bank. + Both light banks */ -static u8 getSmoothLight(enum LightBank bank, v3s16 p, MeshMakeData *data) +static u16 getSmoothLightCombined(const v3s16 &p, MeshMakeData *data) { - static v3s16 dirs8[8] = { + static const v3s16 dirs8[8] = { v3s16(0,0,0), v3s16(0,0,1), v3s16(0,1,0), @@ -239,67 +215,77 @@ static u8 getSmoothLight(enum LightBank bank, v3s16 p, MeshMakeData *data) v3s16(1,1,1), }; - INodeDefManager *ndef = data->m_gamedef->ndef(); + INodeDefManager *ndef = data->m_client->ndef(); u16 ambient_occlusion = 0; - u16 light = 0; u16 light_count = 0; u8 light_source_max = 0; - for(u32 i=0; i<8; i++) + u16 light_day = 0; + u16 light_night = 0; + + for (u32 i = 0; i < 8; i++) { - MapNode n = data->m_vmanip.getNodeNoEx(p - dirs8[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; + } + const ContentFeatures &f = ndef->get(n); - if(f.light_source > light_source_max) + if (f.light_source > light_source_max) light_source_max = f.light_source; - // Check f.solidness because fast-style leaves look - // better this way - if(f.param_type == CPT_LIGHT && f.solidness != 2) - { - light += decode_light(n.getLight(bank, ndef)); + // Check f.solidness because fast-style leaves look better this way + if (f.param_type == CPT_LIGHT && f.solidness != 2) { + light_day += decode_light(n.getLightNoChecks(LIGHTBANK_DAY, &f)); + light_night += decode_light(n.getLightNoChecks(LIGHTBANK_NIGHT, &f)); light_count++; - } - else if(n.getContent() != CONTENT_IGNORE) - { + } else { ambient_occlusion++; } } if(light_count == 0) - return 255; - - light /= light_count; + return 0xffff; + + light_day /= light_count; + light_night /= light_count; // Boost brightness around light sources - if(decode_light(light_source_max) >= light) - //return decode_light(undiminish_light(light_source_max)); - return decode_light(light_source_max); + bool skip_ambient_occlusion_day = false; + if(decode_light(light_source_max) >= light_day) { + light_day = decode_light(light_source_max); + skip_ambient_occlusion_day = true; + } - if(ambient_occlusion > 4) - { - //ambient_occlusion -= 4; - //light = (float)light / ((float)ambient_occlusion * 0.5 + 1.0); - float light_amount = (8 - ambient_occlusion) / 4.0; - float light_f = (float)light / 255.0; - light_f = pow(light_f, 2.2f); // gamma -> linear space - light_f = light_f * light_amount; - light_f = pow(light_f, 1.0f/2.2f); // linear -> gamma space - if(light_f > 1.0) - light_f = 1.0; - light = 255.0 * light_f + 0.5; + bool skip_ambient_occlusion_night = false; + if(decode_light(light_source_max) >= light_night) { + light_night = decode_light(light_source_max); + skip_ambient_occlusion_night = true; } - return light; -} + 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] = { + powf(0.75, 1.0 / ao_gamma), + powf(0.5, 1.0 / ao_gamma), + powf(0.25, 1.0 / ao_gamma) + }; + + //calculate table index for gamma space multiplier + ambient_occlusion -= 5; + + if (!skip_ambient_occlusion_day) + 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); + } -/* - Calculate smooth lighting at the XYZ- corner of p. - Both light banks. -*/ -static u16 getSmoothLight(v3s16 p, MeshMakeData *data) -{ - u16 day = getSmoothLight(LIGHTBANK_DAY, p, data); - u16 night = getSmoothLight(LIGHTBANK_NIGHT, p, data); - return day | (night << 8); + return light_day | (light_night << 8); } /* @@ -309,54 +295,57 @@ static u16 getSmoothLight(v3s16 p, MeshMakeData *data) u16 getSmoothLight(v3s16 p, v3s16 corner, MeshMakeData *data) { if(corner.X == 1) p.X += 1; - else assert(corner.X == -1); + // else corner.X == -1 if(corner.Y == 1) p.Y += 1; - else assert(corner.Y == -1); + // else corner.Y == -1 if(corner.Z == 1) p.Z += 1; - else assert(corner.Z == -1); - - return getSmoothLight(p, data); + // else corner.Z == -1 + + return getSmoothLightCombined(p, data); } -/* - Converts from day + night color values (0..255) - and a given daynight_ratio to the final SColor shown on screen. -*/ -static void finalColorBlend(video::SColor& result, - u8 day, u8 night, u32 daynight_ratio) +void get_sunlight_color(video::SColorf *sunlight, u32 daynight_ratio){ + f32 rg = daynight_ratio / 1000.0f - 0.04f; + f32 b = (0.98f * daynight_ratio) / 1000.0f + 0.078f; + sunlight->r = rg; + sunlight->g = rg; + sunlight->b = b; +} + +void final_color_blend(video::SColor *result, + u16 light, u32 daynight_ratio) +{ + video::SColorf dayLight; + get_sunlight_color(&dayLight, daynight_ratio); + final_color_blend(result, + encode_light(light, 0), dayLight); +} + +void final_color_blend(video::SColor *result, + const video::SColor &data, const video::SColorf &dayLight) { - s32 rg = (day * daynight_ratio + night * (1000-daynight_ratio)) / 1000; - s32 b = rg; + static const video::SColorf artificialColor(1.04f, 1.04f, 1.04f); + + video::SColorf c(data); + f32 n = 1 - c.a; - // Moonlight is blue - b += (day - night) / 13; - rg -= (day - night) / 23; + f32 r = c.r * (c.a * dayLight.r + n * artificialColor.r) * 2.0f; + f32 g = c.g * (c.a * dayLight.g + n * artificialColor.g) * 2.0f; + f32 b = c.b * (c.a * dayLight.b + n * artificialColor.b) * 2.0f; // Emphase blue a bit in darker places // Each entry of this array represents a range of 8 blue levels - static u8 emphase_blue_when_dark[32] = { + static const u8 emphase_blue_when_dark[32] = { 1, 4, 6, 6, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; - if(b < 0) - b = 0; - if(b > 255) - b = 255; - b += emphase_blue_when_dark[b / 8]; - - // Artificial light is yellow-ish - static u8 emphase_yellow_when_artificial[16] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 10, 15, 15, 15 - }; - rg += emphase_yellow_when_artificial[night/16]; - if(rg < 0) - rg = 0; - if(rg > 255) - rg = 255; - - result.setRed(rg); - result.setGreen(rg); - result.setBlue(b); + + b += emphase_blue_when_dark[irr::core::clamp((s32) ((r + g + b) / 3 * 255), + 0, 255) / 8] / 255.0f; + + result->setRed(core::clamp((s32) (r * 255.0f), 0, 255)); + result->setGreen(core::clamp((s32) (g * 255.0f), 0, 255)); + result->setBlue(core::clamp((s32) (b * 255.0f), 0, 255)); } /* @@ -428,21 +417,144 @@ static void getNodeVertexDirs(v3s16 dir, v3s16 *vertex_dirs) 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; }; -static void makeFastFace(TileSpec tile, u16 li0, u16 li1, u16 li2, u16 li3, - v3f p, v3s16 dir, v3f scale, core::array &dest) +static void makeFastFace(const TileSpec &tile, u16 li0, u16 li1, u16 li2, u16 li3, + v3f p, v3s16 dir, v3f scale, std::vector &dest) { - FastFace face; - // 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; + v3f vertex_pos[4]; v3s16 vertex_dirs[4]; getNodeVertexDirs(dir, vertex_dirs); + + v3s16 t; + u16 t1; + switch (tile.rotation) + { + case 0: + break; + case 1: //R90 + t = vertex_dirs[0]; + vertex_dirs[0] = vertex_dirs[3]; + vertex_dirs[3] = vertex_dirs[2]; + vertex_dirs[2] = vertex_dirs[1]; + vertex_dirs[1] = t; + t1=li0; + li0=li3; + li3=li2; + li2=li1; + li1=t1; + break; + case 2: //R180 + t = vertex_dirs[0]; + vertex_dirs[0] = vertex_dirs[2]; + vertex_dirs[2] = t; + t = vertex_dirs[1]; + vertex_dirs[1] = vertex_dirs[3]; + vertex_dirs[3] = t; + t1 = li0; + li0 = li2; + li2 = t1; + t1 = li1; + li1 = li3; + li3 = t1; + break; + case 3: //R270 + t = vertex_dirs[0]; + vertex_dirs[0] = vertex_dirs[1]; + vertex_dirs[1] = vertex_dirs[2]; + vertex_dirs[2] = vertex_dirs[3]; + vertex_dirs[3] = t; + t1 = li0; + li0 = li1; + li1 = li2; + li2 = li3; + li3 = t1; + break; + case 4: //FXR90 + t = vertex_dirs[0]; + vertex_dirs[0] = vertex_dirs[3]; + vertex_dirs[3] = vertex_dirs[2]; + vertex_dirs[2] = vertex_dirs[1]; + vertex_dirs[1] = t; + t1 = li0; + li0 = li3; + li3 = li2; + li2 = li1; + li1 = t1; + y0 += h; + h *= -1; + break; + case 5: //FXR270 + t = vertex_dirs[0]; + vertex_dirs[0] = vertex_dirs[1]; + vertex_dirs[1] = vertex_dirs[2]; + vertex_dirs[2] = vertex_dirs[3]; + vertex_dirs[3] = t; + t1 = li0; + li0 = li1; + li1 = li2; + li2 = li3; + li3 = t1; + y0 += h; + h *= -1; + break; + case 6: //FYR90 + t = vertex_dirs[0]; + vertex_dirs[0] = vertex_dirs[3]; + vertex_dirs[3] = vertex_dirs[2]; + vertex_dirs[2] = vertex_dirs[1]; + vertex_dirs[1] = t; + t1 = li0; + li0 = li3; + li3 = li2; + li2 = li1; + li1 = t1; + x0 += w; + w *= -1; + break; + case 7: //FYR270 + t = vertex_dirs[0]; + vertex_dirs[0] = vertex_dirs[1]; + vertex_dirs[1] = vertex_dirs[2]; + vertex_dirs[2] = vertex_dirs[3]; + vertex_dirs[3] = t; + t1 = li0; + li0 = li1; + li1 = li2; + li2 = li3; + li3 = t1; + x0 += w; + w *= -1; + break; + case 8: //FX + y0 += h; + h *= -1; + break; + case 9: //FY + x0 += w; + w *= -1; + break; + default: + break; + } + for(u16 i=0; i<4; i++) { vertex_pos[i] = v3f( @@ -460,36 +572,57 @@ static void makeFastFace(TileSpec tile, u16 li0, u16 li1, u16 li2, u16 li3, vertex_pos[i] += pos; } - f32 abs_scale = 1.; + 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; v3f normal(dir.X, dir.Y, dir.Z); - u8 alpha = tile.alpha; - - float x0 = tile.texture.pos.X; - float y0 = tile.texture.pos.Y; - float w = tile.texture.size.X; - float h = tile.texture.size.Y; - - face.vertices[0] = video::S3DVertex(vertex_pos[0], normal, - MapBlock_LightColor(alpha, li0), - core::vector2d(x0+w*abs_scale, y0+h)); - face.vertices[1] = video::S3DVertex(vertex_pos[1], normal, - MapBlock_LightColor(alpha, li1), - core::vector2d(x0, y0+h)); - face.vertices[2] = video::S3DVertex(vertex_pos[2], normal, - MapBlock_LightColor(alpha, li2), - core::vector2d(x0, y0)); - face.vertices[3] = video::S3DVertex(vertex_pos[3], normal, - MapBlock_LightColor(alpha, li3), - core::vector2d(x0+w*abs_scale, y0)); - - face.tile = tile; - - dest.push_back(face); + u16 li[4] = { li0, li1, li2, li3 }; + u16 day[4]; + u16 night[4]; + + for (u8 i = 0; i < 4; i++) { + day[i] = li[i] >> 8; + night[i] = li[i] & 0xFF; + } + + bool vertex_0_2_connected = abs(day[0] - day[2]) + abs(night[0] - night[2]) + < abs(day[1] - day[3]) + abs(night[1] - night[3]); + + v2f32 f[4] = { + core::vector2d(x0 + w * abs_scale, y0 + h), + core::vector2d(x0, y0 + h), + core::vector2d(x0, y0), + core::vector2d(x0 + w * abs_scale, y0) }; + + for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++) { + const TileLayer *layer = &tile.layers[layernum]; + if (layer->texture_id == 0) + continue; + + dest.push_back(FastFace()); + FastFace& face = *dest.rbegin(); + + for (u8 i = 0; i < 4; i++) { + video::SColor c = encode_light(li[i], tile.emissive_light); + if (!tile.emissive_light) + applyFacesShading(c, normal); + + face.vertices[i] = video::S3DVertex(vertex_pos[i], normal, c, f[i]); + } + + /* + Revert triangles for nicer looking gradient if the + brightness of vertices 1 and 3 differ less than + the brightness of vertices 0 and 2. + */ + face.vertex_0_2_connected = vertex_0_2_connected; + + face.layer = *layer; + face.layernum = layernum; + } } /* @@ -509,16 +642,16 @@ static u8 face_contents(content_t m1, content_t m2, bool *equivalent, if(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; - + u8 c1 = f1.solidness; u8 c2 = f2.solidness; @@ -527,12 +660,12 @@ static u8 face_contents(content_t m1, content_t m2, bool *equivalent, if(makes_face == false) return 0; - + if(c1 == 0) c1 = f1.visual_solidness; if(c2 == 0) c2 = f2.visual_solidness; - + if(c1 == c2){ *equivalent = true; // If same solidness, liquid takes precense @@ -541,7 +674,7 @@ static u8 face_contents(content_t m1, content_t m2, bool *equivalent, if(f2.isLiquid()) return 2; } - + if(c1 > c2) return 1; else @@ -551,30 +684,31 @@ static u8 face_contents(content_t m1, content_t m2, bool *equivalent, /* 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_gamedef->ndef(); - TileSpec spec = ndef->get(mn).tiles[tileindex]; - // Apply temporary crack - if(p == data->m_crack_pos_relative) - { - spec.material_flags |= MATERIAL_FLAG_CRACK; - spec.texture = data->m_gamedef->tsrc()->getTextureRawAP(spec.texture); - } - // If animated, replace tile texture with one without texture atlas - if(spec.material_flags & MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES) - { - spec.texture = data->m_gamedef->tsrc()->getTextureRawAP(spec.texture); + INodeDefManager *ndef = data->m_client->ndef(); + const ContentFeatures &f = ndef->get(mn); + tile = f.tiles[tileindex]; + TileLayer *top_layer = NULL; + for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++) { + TileLayer *layer = &tile.layers[layernum]; + if (layer->texture_id == 0) + continue; + top_layer = layer; + if (!layer->has_color) + mn.getColor(f, &(layer->color)); } - return spec; + // Apply temporary crack + if (p == data->m_crack_pos_relative) + top_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_gamedef->ndef(); + INodeDefManager *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) @@ -589,29 +723,55 @@ 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; + u8 dir_i = ((dir.X + 2 * dir.Y + 3 * dir.Z) & 7)*2; // Get rotation for things like chests u8 facedir = mn.getFaceDir(ndef); - assert(facedir <= 3); - - static const u8 dir_to_tile[4 * 8] = + + static const u16 dir_to_tile[24 * 16] = { - // 0 +X +Y +Z 0 -Z -Y -X - 0, 2, 0, 4, 0, 5, 1, 3, // facedir = 0 - 0, 4, 0, 3, 0, 2, 1, 5, // facedir = 1 - 0, 3, 0, 5, 0, 4, 1, 2, // facedir = 2 - 0, 5, 0, 2, 0, 3, 1, 4, // facedir = 3 + // 0 +X +Y +Z -Z -Y -X -> value=tile,rotation + 0,0, 2,0 , 0,0 , 4,0 , 0,0, 5,0 , 1,0 , 3,0 , // rotate around y+ 0 - 3 + 0,0, 4,0 , 0,3 , 3,0 , 0,0, 2,0 , 1,1 , 5,0 , + 0,0, 3,0 , 0,2 , 5,0 , 0,0, 4,0 , 1,2 , 2,0 , + 0,0, 5,0 , 0,1 , 2,0 , 0,0, 3,0 , 1,3 , 4,0 , + + 0,0, 2,3 , 5,0 , 0,2 , 0,0, 1,0 , 4,2 , 3,1 , // rotate around z+ 4 - 7 + 0,0, 4,3 , 2,0 , 0,1 , 0,0, 1,1 , 3,2 , 5,1 , + 0,0, 3,3 , 4,0 , 0,0 , 0,0, 1,2 , 5,2 , 2,1 , + 0,0, 5,3 , 3,0 , 0,3 , 0,0, 1,3 , 2,2 , 4,1 , + + 0,0, 2,1 , 4,2 , 1,2 , 0,0, 0,0 , 5,0 , 3,3 , // rotate around z- 8 - 11 + 0,0, 4,1 , 3,2 , 1,3 , 0,0, 0,3 , 2,0 , 5,3 , + 0,0, 3,1 , 5,2 , 1,0 , 0,0, 0,2 , 4,0 , 2,3 , + 0,0, 5,1 , 2,2 , 1,1 , 0,0, 0,1 , 3,0 , 4,3 , + + 0,0, 0,3 , 3,3 , 4,1 , 0,0, 5,3 , 2,3 , 1,3 , // rotate around x+ 12 - 15 + 0,0, 0,2 , 5,3 , 3,1 , 0,0, 2,3 , 4,3 , 1,0 , + 0,0, 0,1 , 2,3 , 5,1 , 0,0, 4,3 , 3,3 , 1,1 , + 0,0, 0,0 , 4,3 , 2,1 , 0,0, 3,3 , 5,3 , 1,2 , + + 0,0, 1,1 , 2,1 , 4,3 , 0,0, 5,1 , 3,1 , 0,1 , // rotate around x- 16 - 19 + 0,0, 1,2 , 4,1 , 3,3 , 0,0, 2,1 , 5,1 , 0,0 , + 0,0, 1,3 , 3,1 , 5,3 , 0,0, 4,1 , 2,1 , 0,3 , + 0,0, 1,0 , 5,1 , 2,3 , 0,0, 3,1 , 4,1 , 0,2 , + + 0,0, 3,2 , 1,2 , 4,2 , 0,0, 5,2 , 0,2 , 2,2 , // rotate around y- 20 - 23 + 0,0, 5,2 , 1,3 , 3,2 , 0,0, 2,2 , 0,1 , 4,2 , + 0,0, 2,2 , 1,0 , 5,2 , 0,0, 4,2 , 0,0 , 3,2 , + 0,0, 4,2 , 1,1 , 2,2 , 0,0, 3,2 , 0,3 , 5,2 + }; - u8 tileindex = dir_to_tile[facedir*8 + dir_i]; - return getNodeTileN(mn, p, tileindex, data); + u16 tile_index=facedir*16 + dir_i; + getNodeTileN(mn, p, dir_to_tile[tile_index], data, tile); + tile.rotation = dir_to_tile[tile_index + 1]; } static void getTileInfo( // Input: MeshMakeData *data, - v3s16 p, - v3s16 face_dir, + const v3s16 &p, + const v3s16 &face_dir, // Output: bool &makes_face, v3s16 &p_corrected, @@ -621,62 +781,71 @@ static void getTileInfo( ) { VoxelManipulator &vmanip = data->m_vmanip; - INodeDefManager *ndef = data->m_gamedef->ndef(); + INodeDefManager *ndef = data->m_client->ndef(); v3s16 blockpos_nodes = data->m_blockpos * MAP_BLOCKSIZE; - MapNode n0 = vmanip.getNodeNoEx(blockpos_nodes + p); - MapNode n1 = vmanip.getNodeNoEx(blockpos_nodes + p + face_dir); - TileSpec tile0 = getNodeTile(n0, p, face_dir, data); - TileSpec tile1 = getNodeTile(n1, p + face_dir, -face_dir, data); - + const MapNode &n0 = vmanip.getNodeRefUnsafe(blockpos_nodes + p); + + // Don't even try to get n1 if n0 is already CONTENT_IGNORE + if (n0.getContent() == CONTENT_IGNORE) { + makes_face = false; + return; + } + + const MapNode &n1 = vmanip.getNodeRefUnsafeCheckFlags(blockpos_nodes + p + face_dir); + + if (n1.getContent() == CONTENT_IGNORE) { + makes_face = false; + return; + } + // This is hackish bool equivalent = false; u8 mf = face_contents(n0.getContent(), n1.getContent(), &equivalent, ndef); - if(mf == 0) - { + if (mf == 0) { makes_face = false; return; } makes_face = true; - - if(mf == 1) - { - tile = tile0; + + MapNode n = n0; + + if (mf == 1) { p_corrected = p; face_dir_corrected = face_dir; - } - else - { - tile = tile1; + } else { + n = n1; p_corrected = p + face_dir; face_dir_corrected = -face_dir; } - + + getNodeTile(n, p_corrected, face_dir_corrected, data, tile); + const ContentFeatures &f = ndef->get(n); + tile.emissive_light = f.light_source; + // eg. water and glass - if(equivalent) - tile.material_flags |= MATERIAL_FLAG_BACKFACE_CULLING; - - if(data->m_smooth_lighting == false) - { + if (equivalent) { + for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++) + tile.layers[layernum].material_flags |= + MATERIAL_FLAG_BACKFACE_CULLING; + } + + if (!data->m_smooth_lighting) { lights[0] = lights[1] = lights[2] = lights[3] = - getFaceLight(n0, n1, face_dir, data); + 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); + + v3s16 light_p = blockpos_nodes + p_corrected; + for (u16 i = 0; i < 4; i++) { + lights[i] = getSmoothLight(light_p, vertex_dirs[i], data); } } - - return; } /* @@ -686,172 +855,116 @@ 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, - core::array &dest) + const v3f &&translate_dir_f, + const v3s16 &&face_dir, + std::vector &dest) { v3s16 p = startpos; - - u16 continuous_tiles_count = 0; - + + u16 continuous_tiles_count = 1; + bool makes_face = false; v3s16 p_corrected; v3s16 face_dir_corrected; u16 lights[4] = {0,0,0,0}; TileSpec tile; - getTileInfo(data, p, face_dir, + 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);*/ } - continuous_tiles_count++; - - // This is set to true if the texture doesn't allow more tiling - bool end_of_texture = false; - /* - If there is no texture, it can be tiled infinitely. - If tiled==0, it means the texture can be tiled infinitely. - Otherwise check tiled agains continuous_tiles_count. - */ - if(tile.texture.atlas != NULL && tile.texture.tiled != 0) - { - if(tile.texture.tiled <= continuous_tiles_count) - end_of_texture = true; - } - - // Do this to disable tiling textures - //end_of_texture = true; //DEBUG - - if(next_is_different || end_of_texture) - { + 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.5) * translate_dir_f; - if(continuous_tiles_count != 1) - sp += translate_dir_f; + v3f sp = pf - + ((f32)continuous_tiles_count / 2.0f - 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); - + sp, face_dir_corrected, scale, dest); + g_profiler->avg("Meshgen: faces drawn by tiling", 0); - for(int i=1; iavg("Meshgen: faces drawn by tiling", 1); } } - continuous_tiles_count = 0; - - 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; + continuous_tiles_count = 1; } - + + makes_face = next_makes_face; + p_corrected = next_p_corrected; + face_dir_corrected = next_face_dir_corrected; + std::memcpy(lights, next_lights, ARRLEN(lights) * sizeof(u16)); + if (next_is_different) + tile = next_tile; p = p_next; } } static void updateAllFastFaceRows(MeshMakeData *data, - core::array &dest) + std::vector &dest) { /* Go through every y,z and get top(y+) faces in rows of x+ */ - for(s16 y=0; ym_gamedef), +MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset): + m_minimap_mapblock(NULL), + m_tsrc(data->m_client->getTextureSource()), + m_shdrsrc(data->m_client->getShaderSource()), m_animation_force_timer(0), // force initial animation m_last_crack(-1), - m_crack_materials(), - m_last_daynight_ratio((u32) -1), - m_daynight_diffs() + m_last_daynight_ratio((u32) -1) { + for (int m = 0; m < MAX_TILE_LAYERS; m++) + m_mesh[m] = new scene::SMesh(); + m_enable_shaders = data->m_use_shaders; + m_use_tangent_vertices = data->m_use_tangent_vertices; + m_enable_vbo = g_settings->getBool("enable_vbo"); + + if (g_settings->getBool("enable_minimap")) { + m_minimap_mapblock = new MinimapMapblock; + m_minimap_mapblock->getMinimapNodes( + &data->m_vmanip, data->m_blockpos * MAP_BLOCKSIZE); + } + // 4-21ms for MAP_BLOCKSIZE=16 (NOTE: probably outdated) // 24-155ms for MAP_BLOCKSIZE=32 (NOTE: probably outdated) //TimeTaker timer1("MapBlockMesh()"); - core::array fastfaces_new; + std::vector fastfaces_new; + fastfaces_new.reserve(512); /* We are including the faces of the trailing edges of the block. @@ -924,35 +1047,27 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data): Convert FastFaces to MeshCollector */ - MeshCollector collector; + MeshCollector collector(m_use_tangent_vertices); { // avg 0ms (100ms spikes when loading textures the first time) // (NOTE: probably outdated) //TimeTaker timer2("MeshCollector building"); - for(u32 i=0; im_gamedef->tsrc(); - // 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<getTextureName(p.layer.texture_id)<<"^[crack"; + if(p.layer.material_flags & MATERIAL_FLAG_CRACK_OVERLAY) + os<<"o"; // use ^[cracko + 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); + } + // - 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 { + // Play all synchronized + m_animation_frame_offsets[std::pair(layer, i)] = 0; + } + // Replace tile texture with the first animation frame + p.layer.texture = p.layer.frames[0].texture; } - // Replace tile texture with the first animation frame - std::ostringstream os(std::ios::binary); - os<getTextureName(p.tile.texture.id); - os<<"^[verticalframe:"<<(int)p.tile.animation_frame_count<<":0"; - p.tile.texture = tsrc->getTexture(os.str()); - } - // - Lighting - for(u32 j = 0; j < p.vertices.size(); j++) - { - video::SColor &vc = p.vertices[j].Color; - u8 day = vc.getRed(); - u8 night = vc.getGreen(); - finalColorBlend(vc, day, night, 1000); - if(day != night) - m_daynight_diffs[i][j] = std::make_pair(day, night); - } + 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); + } + } - // 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.setFlag(video::EMF_ANTI_ALIASING, video::EAAM_OFF); - //material.setFlag(video::EMF_ANTI_ALIASING, video::EAAM_SIMPLE); - material.MaterialType - = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF; - material.setTexture(0, p.tile.texture.atlas); - p.tile.applyMaterialOptions(material); - - // Create meshbuffer - - // This is a "Standard MeshBuffer", - // it's a typedeffed CMeshBuffer - scene::SMeshBuffer *buf = new scene::SMeshBuffer(); - // Set material - buf->Material = material; - // Add to mesh - m_mesh->addMeshBuffer(buf); - // Mesh grabbed it - buf->drop(); - buf->append(p.vertices.pointer(), p.vertices.size(), - p.indices.pointer(), p.indices.size()); - } + // 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); + } - /* - Do some stuff to the mesh - */ + 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()); + } + } - translateMesh(m_mesh, intToFloat(data->m_blockpos * MAP_BLOCKSIZE, BS)); - m_mesh->recalculateBoundingBox(); // translateMesh already does this - if(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)); + + if (m_use_tangent_vertices) { + scene::IMeshManipulator* meshmanip = + RenderingEngine::get_scene_manager()->getMeshManipulator(); + meshmanip->recalculateTangents(m_mesh[layer], true, false, false); + } + + 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)"<setHardwareMappingHint(scene::EHM_STATIC); - - /* - NOTE: If that is enabled, some kind of a queue to the main - thread should be made which would call irrlicht to delete - the hardware buffer and then delete the mesh - */ + // Use VBO for mesh (this just would set this for ever buffer) + if (m_enable_vbo) { + m_mesh[layer]->setHardwareMappingHint(scene::EHM_STATIC); + } + } } - + //std::cout<<"added "<drop(); - m_mesh = NULL; + for (int m = 0; m < MAX_TILE_LAYERS; m++) { + if (m_enable_vbo && m_mesh[m]) + for (u32 i = 0; i < m_mesh[m]->getMeshBufferCount(); i++) { + scene::IMeshBuffer *buf = m_mesh[m]->getMeshBuffer(i); + RenderingEngine::get_video_driver()->removeHardwareBuffer(buf); + } + m_mesh[m]->drop(); + m_mesh[m] = NULL; + } + delete m_minimap_mapblock; } bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_ratio) @@ -1107,30 +1267,40 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat // Cracks if(crack != m_last_crack) { - for(std::map::iterator - i = m_crack_materials.begin(); - i != m_crack_materials.end(); i++) - { - scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first); + for (std::map, std::string>::iterator i = + m_crack_materials.begin(); i != m_crack_materials.end(); ++i) { + scene::IMeshBuffer *buf = m_mesh[i->first.first]-> + getMeshBuffer(i->first.second); std::string basename = i->second; // Create new texture name from original - ITextureSource *tsrc = m_gamedef->getTextureSource(); std::ostringstream os; os<getTexture(os.str()); - buf->getMaterial().setTexture(0, ap.atlas); + u32 new_texture_id = 0; + video::ITexture *new_texture = + m_tsrc->getTextureForMesh(os.str(), &new_texture_id); + buf->getMaterial().setTexture(0, new_texture); + + // If the current material is also animated, + // update animation info + std::map, TileLayer>::iterator anim_iter = + m_animation_tiles.find(i->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_last_crack = crack; } - + // Texture animation - for(std::map::iterator - i = m_animation_tiles.begin(); - i != m_animation_tiles.end(); i++) - { - const TileSpec &tile = i->second; + for (std::map, TileLayer>::iterator i = + m_animation_tiles.begin(); i != m_animation_tiles.end(); ++i) { + const TileLayer &tile = i->second; // Figure out current frame int frameoffset = m_animation_frame_offsets[i->first]; int frame = (int)(time * 1000 / tile.animation_frame_length_ms @@ -1141,36 +1311,41 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat m_animation_frames[i->first] = frame; - scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first); - ITextureSource *tsrc = m_gamedef->getTextureSource(); + scene::IMeshBuffer *buf = m_mesh[i->first.first]-> + getMeshBuffer(i->first.second); - // Create new texture name from original - std::ostringstream os(std::ios::binary); - os<getTextureName(tile.texture.id); - os<<"^[verticalframe:"<<(int)tile.animation_frame_count<<":"<getTexture(os.str()); - buf->getMaterial().setTexture(0, ap.atlas); + 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); + } + buf->getMaterial().setTexture(2, animation_frame.flags_texture); + } } // Day-night transition - if(daynight_ratio != m_last_daynight_ratio) + if(!m_enable_shaders && (daynight_ratio != m_last_daynight_ratio)) { - for(std::map > >::iterator + // Force reload mesh to VBO + if (m_enable_vbo) + for (int m = 0; m < MAX_TILE_LAYERS; m++) + m_mesh[m]->setDirty(); + video::SColorf day_color; + get_sunlight_color(&day_color, daynight_ratio); + for(std::map, std::map >::iterator i = m_daynight_diffs.begin(); - i != m_daynight_diffs.end(); i++) + i != m_daynight_diffs.end(); ++i) { - scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first); - video::S3DVertex *vertices = (video::S3DVertex*)buf->getVertices(); - for(std::map >::iterator + scene::IMeshBuffer *buf = m_mesh[i->first.first]-> + getMeshBuffer(i->first.second); + video::S3DVertex *vertices = (video::S3DVertex *)buf->getVertices(); + for(std::map::iterator j = i->second.begin(); - j != i->second.end(); j++) + j != i->second.end(); ++j) { - u32 vertexIndex = j->first; - u8 day = j->second.first; - u8 night = j->second.second; - finalColorBlend(vertices[vertexIndex].Color, - day, night, daynight_ratio); + final_color_blend(&(vertices[j->first].Color), + j->second, day_color); } } m_last_daynight_ratio = daynight_ratio; @@ -1179,6 +1354,20 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat return true; } +void MapBlockMesh::updateCameraOffset(v3s16 camera_offset) +{ + if (camera_offset != m_camera_offset) { + for (u8 layer = 0; layer < 2; layer++) { + translateMesh(m_mesh[layer], + intToFloat(m_camera_offset - camera_offset, BS)); + if (m_enable_vbo) { + m_mesh[layer]->setDirty(); + } + } + m_camera_offset = camera_offset; + } +} + /* MeshCollector */ @@ -1187,38 +1376,203 @@ 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); + } +} + +void MeshCollector::append(const TileLayer &layer, + const video::S3DVertex *vertices, u32 numVertices, + const u16 *indices, u32 numIndices, u8 layernum) +{ + if (numIndices > 65535) { + dstream<<"FIXME: MeshCollector::append() called with numIndices="< *buffers = &prebuffers[layernum]; + PreMeshBuffer *p = NULL; - for(u32 i=0; isize(); i++) { + PreMeshBuffer &pp = (*buffers)[i]; + if (pp.layer != layer) + continue; + if (pp.indices.size() + numIndices > 65535) continue; p = &pp; break; } - if(p == NULL) - { + 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]; } - u32 vertex_count = p->vertices.size(); - for(u32 i=0; i 65535) - { - dstream<<"FIXME: Meshbuffer ran out of indices"<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); + 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); + p->vertices.push_back(vert); } + } + + for (u32 i = 0; i < numIndices; i++) { + u32 j = indices[i] + vertex_count; p->indices.push_back(j); } - for(u32 i=0; ivertices.push_back(vertices[i]); +} + +/* + MeshCollector - for meshnodes and converted drawtypes. +*/ + +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); } } + +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) +{ + if (numIndices > 65535) { + dstream<<"FIXME: MeshCollector::append() called with numIndices="< *buffers = &prebuffers[layernum]; + + PreMeshBuffer *p = NULL; + for (u32 i = 0; i < buffers->size(); i++) { + PreMeshBuffer &pp = (*buffers)[i]; + if(pp.layer != layer) + continue; + if(pp.indices.size() + numIndices > 65535) + continue; + + p = &pp; + break; + } + + if (p == NULL) { + PreMeshBuffer pp; + pp.layer = layer; + buffers->push_back(pp); + p = &(*buffers)[buffers->size() - 1]; + } + + video::SColor original_c = c; + u32 vertex_count; + if (m_use_tangent_vertices) { + vertex_count = p->tangent_vertices.size(); + for (u32 i = 0; i < numVertices; i++) { + if (!light_source) { + c = original_c; + applyFacesShading(c, vertices[i].Normal); + } + video::S3DVertexTangents vert(vertices[i].Pos + pos, + vertices[i].Normal, c, vertices[i].TCoords); + p->tangent_vertices.push_back(vert); + } + } else { + vertex_count = p->vertices.size(); + for (u32 i = 0; i < numVertices; i++) { + if (!light_source) { + c = original_c; + applyFacesShading(c, vertices[i].Normal); + } + video::S3DVertex vert(vertices[i].Pos + pos, vertices[i].Normal, c, + vertices[i].TCoords); + p->vertices.push_back(vert); + } + } + + for (u32 i = 0; i < numIndices; i++) { + u32 j = indices[i] + vertex_count; + p->indices.push_back(j); + } +} + +void MeshCollector::applyTileColors() +{ + if (m_use_tangent_vertices) + for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) { + for (auto &pmb : prebuffers[layer]) { + video::SColor tc = pmb.layer.color; + if (tc == video::SColor(0xFFFFFFFF)) + continue; + for (auto &tangent_vertice : pmb.tangent_vertices) { + video::SColor *c = &tangent_vertice.Color; + c->set(c->getAlpha(), c->getRed() * tc.getRed() / 255, + c->getGreen() * tc.getGreen() / 255, + c->getBlue() * tc.getBlue() / 255); + } + } + } + else + for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) { + for (auto &pmb : prebuffers[layer]) { + video::SColor tc = pmb.layer.color; + if (tc == video::SColor(0xFFFFFFFF)) + continue; + for (auto &vertice : pmb.vertices) { + video::SColor *c = &vertice.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 + u32 day = (light & 0xff); + u32 night = (light >> 8); + // Add emissive light + night += emissive_light * 2.5f; + if (night > 255) + night = 255; + // Since we don't know if the day light is sunlight or + // artificial light, assume it is artificial when the night + // light bank is also lit. + if (day < night) + day = 0; + else + day = day - night; + u32 sum = day + night; + // Ratio of sunlight: + u32 r; + if (sum > 0) + r = day * 255 / sum; + else + r = 0; + // Average light: + float b = (day + night) / 2; + return video::SColor(r, b, b, b); +}