*/
#include "mapblock_mesh.h"
+#include "client.h"
#include "mapblock.h"
#include "map.h"
#include "profiler.h"
+#include "shader.h"
#include "mesh.h"
#include "minimap.h"
#include "content_mapblock.h"
#include "util/directiontables.h"
#include "client/renderingengine.h"
+#include <array>
/*
MeshMakeData
fillBlockData(v3s16(0,0,0), block->getData());
- // Get map for reading neigbhor blocks
+ // Get map for reading neighbor blocks
Map *map = block->getParent();
- for (u16 i=0; i<26; i++) {
- const v3s16 &dir = g_26dirs[i];
+ for (const v3s16 &dir : g_26dirs) {
v3s16 bp = m_blockpos + dir;
MapBlock *b = map->getBlockNoCreateNoEx(bp);
if(b)
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;
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;
}
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);
}
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);
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);
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);
Calculate smooth lighting at the XYZ- corner of p.
Both light banks
*/
-static u16 getSmoothLightCombined(const v3s16 &p, MeshMakeData *data)
+static u16 getSmoothLightCombined(const v3s16 &p,
+ const std::array<v3s16,8> &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;
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;
} else {
ambient_occlusion++;
}
- }
+ return f.light_propagates;
+ };
- if(light_count == 0)
- return 0xffff;
+ std::array<bool, 4> 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;
}
skip_ambient_occlusion_night = true;
}
- if (ambient_occlusion > 4)
- {
+ 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)
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);
/*
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<v3s16,8> 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){
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);
}
}
+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
{
TileLayer layer;
*/
bool vertex_0_2_connected;
u8 layernum;
+ bool world_aligned;
};
static void makeFastFace(const TileSpec &tile, u16 li0, u16 li1, u16 li2, u16 li3,
- v3f p, v3s16 dir, v3f scale, std::vector<FastFace> &dest)
+ v3f tp, v3f p, v3s16 dir, v3f scale, std::vector<FastFace> &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
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];
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);
face.layer = *layer;
face.layernum = layernum;
+
+ face.world_aligned = tile.world_aligned;
}
}
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;
}
/*
*/
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);
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)
+ bool has_crack = p == data->m_crack_pos_relative;
+ for (TileLayer &layer : tile.layers) {
+ if (layer.texture_id == 0)
continue;
- top_layer = layer;
- if (!layer->has_color)
- mn.getColor(f, &(layer->color));
+ if (!layer.has_color)
+ mn.getColor(f, &(layer.color));
+ // Apply temporary crack
+ if (has_crack)
+ layer.material_flags |= MATERIAL_FLAG_CRACK;
}
- // Apply temporary crack
- if (p == data->m_crack_pos_relative)
- top_layer->material_flags |= MATERIAL_FLAG_CRACK;
}
/*
*/
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)
// 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);
0,0, 4,2 , 1,1 , 2,2 , 0,0, 3,2 , 0,3 , 5,2
};
- u16 tile_index=facedir*16 + dir_i;
+ 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];
+ tile.rotation = tile.world_aligned ? 0 : dir_to_tile[tile_index + 1];
}
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;
const MapNode &n0 = vmanip.getNodeRefUnsafe(blockpos_nodes + p);
// eg. water and glass
if (equivalent) {
- for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++)
- tile.layers[layernum].material_flags |=
- MATERIAL_FLAG_BACKFACE_CULLING;
+ for (TileLayer &layer : tile.layers)
+ layer.material_flags |= MATERIAL_FLAG_BACKFACE_CULLING;
}
if (!data->m_smooth_lighting) {
lights[0] = lights[1] = lights[2] = lights[3] =
getFaceLight(n0, n1, face_dir, ndef);
- }
- else {
+ } else {
v3s16 vertex_dirs[4];
getNodeVertexDirs(face_dir_corrected, vertex_dirs);
v3s16 light_p = blockpos_nodes + p_corrected;
- for (u16 i = 0; i < 4; i++) {
- lights[i] = getSmoothLight(light_p, vertex_dirs[i], data);
- }
+ for (u16 i = 0; i < 4; i++)
+ lights[i] = getSmoothLightSolid(light_p, face_dir_corrected, vertex_dirs[i], data);
}
}
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,
bool next_makes_face = false;
v3s16 next_p_corrected;
v3s16 next_face_dir_corrected;
- u16 next_lights[4] = {0,0,0,0};
-
+ u16 next_lights[4] = {0, 0, 0, 0};
// If at last position, there is nothing to compare to and
// the face must be drawn anyway
continuous_tiles_count++;
}
}
-
if (next_is_different) {
/*
Create a face if there should be one
// 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.0f - 0.5f) * 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;
/*
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
- 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
- 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
- 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);
}
/*
m_last_crack(-1),
m_last_daynight_ratio((u32) -1)
{
- for (int m = 0; m < MAX_TILE_LAYERS; m++)
- m_mesh[m] = new scene::SMesh();
+ 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");
// (NOTE: probably outdated)
//TimeTaker timer2("MeshCollector building");
- for (u32 i = 0; i < fastfaces_new.size(); i++) {
- FastFace &f = fastfaces_new[i];
-
- const u16 indices[] = {0,1,2,2,3,0};
- const u16 indices_alternate[] = {0,1,3,2,3,1};
+ 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};
if (!f.layer.texture)
continue;
f.vertex_0_2_connected ? indices : indices_alternate;
collector.append(f.layer, f.vertices, 4, indices_p, 6,
- f.layernum);
+ f.layernum, f.world_aligned);
}
}
// Generate animation data
// - Cracks
- if(p.layer.material_flags & MATERIAL_FLAG_CRACK)
- {
+ 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
- os<<":"<<(u32)p.layer.animation_frame_count<<":";
- m_crack_materials.insert(std::make_pair(std::pair<u8, u32>(layer, i), os.str()));
+ 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<u8, u32>(layer, i), os.str()));
// Replace tile texture with the cracked one
p.layer.texture = m_tsrc->getTextureForMesh(
- os.str()+"0",
+ os.str() + "0",
&p.layer.texture_id);
}
// - Texture animation
// Add to MapBlockMesh in order to animate these tiles
m_animation_tiles[std::pair<u8, u32>(layer, i)] = p.layer;
m_animation_frames[std::pair<u8, u32>(layer, i)] = 0;
- if(g_settings->getBool("desynchronize_mapblock_texture_animation")){
+ if (g_settings->getBool(
+ "desynchronize_mapblock_texture_animation")) {
// Get starting position from noise
- m_animation_frame_offsets[std::pair<u8, u32>(layer, i)] = 100000 * (2.0 + noise3d(
+ m_animation_frame_offsets[std::pair<u8, u32>(layer, i)] =
+ 100000 * (2.0 + noise3d(
data->m_blockpos.X, data->m_blockpos.Y,
data->m_blockpos.Z, 0));
} else {
// Dummy sunlight to handle non-sunlit areas
video::SColorf sunlight;
get_sunlight_color(&sunlight, 0);
- u32 vertex_count =
- m_use_tangent_vertices ?
+ 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;
material.setTexture(0, p.layer.texture);
if (m_enable_shaders) {
- material.MaterialType = m_shdrsrc->getShaderInfo(p.layer.shader_id).material;
+ material.MaterialType = m_shdrsrc->getShaderInfo(
+ p.layer.shader_id).material;
p.layer.applyMaterialOptionsWithShaders(material);
- if (p.layer.normal_texture) {
+ if (p.layer.normal_texture)
material.setTexture(1, p.layer.normal_texture);
- }
material.setTexture(2, p.layer.flags_texture);
} else {
p.layer.applyMaterialOptions(material);
// Create meshbuffer, add to mesh
if (m_use_tangent_vertices) {
- scene::SMeshBufferTangents *buf = new scene::SMeshBufferTangents();
+ scene::SMeshBufferTangents *buf =
+ new scene::SMeshBufferTangents();
// Set material
buf->Material = material;
// Add to mesh
}
}
-
/*
Do some stuff to the mesh
*/
meshmanip->recalculateTangents(m_mesh[layer], true, false, false);
}
- if (m_mesh[layer])
- {
+ if (m_mesh[layer]) {
#if 0
// Usually 1-700 faces and 1-7 materials
- std::cout<<"Updated MapBlock has "<<fastfaces_new.size()<<" faces "
- <<"and uses "<<m_mesh[layer]->getMeshBufferCount()
- <<" materials (meshbuffers)"<<std::endl;
+ std::cout << "Updated MapBlock has " << fastfaces_new.size()
+ << " faces and uses " << m_mesh[layer]->getMeshBufferCount()
+ << " materials (meshbuffers)" << std::endl;
#endif
// Use VBO for mesh (this just would set this for ever buffer)
- if (m_enable_vbo) {
+ if (m_enable_vbo)
m_mesh[layer]->setHardwareMappingHint(scene::EHM_STATIC);
- }
}
}
MapBlockMesh::~MapBlockMesh()
{
- 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);
+ 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_mesh[m]->drop();
- m_mesh[m] = NULL;
+ m->drop();
+ m = 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;
}
m_animation_force_timer = myrand_range(5, 100);
// Cracks
- if(crack != m_last_crack)
- {
- for (std::map<std::pair<u8, u32>, 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;
+ 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<<basename<<crack;
+ os << basename << crack;
u32 new_texture_id = 0;
video::ITexture *new_texture =
- m_tsrc->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
- std::map<std::pair<u8, u32>, TileLayer>::iterator anim_iter =
- m_animation_tiles.find(i->first);
- if (anim_iter != m_animation_tiles.end()){
+ 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;
}
}
}
// Texture animation
- for (std::map<std::pair<u8, u32>, TileLayer>::iterator i =
- m_animation_tiles.begin(); i != m_animation_tiles.end(); ++i) {
- const TileLayer &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[i->first.first]->
- getMeshBuffer(i->first.second);
+ scene::IMeshBuffer *buf = m_mesh[animation_tile.first.first]->
+ getMeshBuffer(animation_tile.first.second);
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)
- for (int m = 0; m < MAX_TILE_LAYERS; m++)
- m_mesh[m]->setDirty();
+ for (scene::IMesh *m : m_mesh)
+ m->setDirty();
video::SColorf day_color;
get_sunlight_color(&day_color, daynight_ratio);
- for(std::map<std::pair<u8, u32>, std::map<u32, video::SColor > >::iterator
- i = m_daynight_diffs.begin();
- i != m_daynight_diffs.end(); ++i)
- {
- scene::IMeshBuffer *buf = m_mesh[i->first.first]->
- getMeshBuffer(i->first.second);
+
+ 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<u32, video::SColor >::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;
}
void MapBlockMesh::updateCameraOffset(v3s16 camera_offset)
{
if (camera_offset != m_camera_offset) {
- for (u8 layer = 0; layer < 2; layer++) {
- translateMesh(m_mesh[layer],
+ for (scene::IMesh *layer : m_mesh) {
+ translateMesh(layer,
intToFloat(m_camera_offset - camera_offset, BS));
- if (m_enable_vbo) {
- m_mesh[layer]->setDirty();
- }
+ if (m_enable_vbo)
+ layer->setDirty();
}
m_camera_offset = camera_offset;
}
if (layer->texture_id == 0)
continue;
append(*layer, vertices, numVertices, indices, numIndices,
- layernum);
+ layernum, tile.world_aligned);
}
}
void MeshCollector::append(const TileLayer &layer,
const video::S3DVertex *vertices, u32 numVertices,
- const u16 *indices, u32 numIndices, u8 layernum)
+ const u16 *indices, u32 numIndices, u8 layernum,
+ bool use_scale)
{
if (numIndices > 65535) {
- dstream<<"FIXME: MeshCollector::append() called with numIndices="<<numIndices<<" (limit 65535)"<<std::endl;
+ dstream << "FIXME: MeshCollector::append() called with numIndices="
+ << numIndices << " (limit 65535)" << std::endl;
return;
}
std::vector<PreMeshBuffer> *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;
+ for (PreMeshBuffer &pp : *buffers) {
+ if (pp.layer == layer && pp.indices.size() + numIndices <= 65535) {
+ p = &pp;
+ break;
+ }
}
if (p == NULL) {
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);
}
}
if (layer->texture_id == 0)
continue;
append(*layer, vertices, numVertices, indices, numIndices, pos,
- c, light_source, layernum);
+ 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)
+ v3f pos, video::SColor c, u8 light_source, u8 layernum,
+ bool use_scale)
{
if (numIndices > 65535) {
- dstream<<"FIXME: MeshCollector::append() called with numIndices="<<numIndices<<" (limit 65535)"<<std::endl;
+ dstream << "FIXME: MeshCollector::append() called with numIndices="
+ << numIndices << " (limit 65535)" << std::endl;
return;
}
std::vector<PreMeshBuffer> *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;
+ for (PreMeshBuffer &pp : *buffers) {
+ if (pp.layer == layer && pp.indices.size() + numIndices <= 65535) {
+ p = &pp;
+ break;
+ }
}
if (p == NULL) {
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) {
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 {
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);
}
}
void MeshCollector::applyTileColors()
{
if (m_use_tangent_vertices)
- for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
- for (auto &pmb : prebuffers[layer]) {
+ for (auto &prebuffer : prebuffers) {
+ for (PreMeshBuffer &pmb : prebuffer) {
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;
+ 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 (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
- for (auto &pmb : prebuffers[layer]) {
+ for (auto &prebuffer : prebuffers) {
+ for (PreMeshBuffer &pmb : prebuffer) {
video::SColor tc = pmb.layer.color;
if (tc == video::SColor(0xFFFFFFFF))
continue;
- for (auto &vertice : pmb.vertices) {
- video::SColor *c = &vertice.Color;
+ 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);
projects / dragonfireclient.git / blobdiff