textures/base/pack/rangeview_btn.png

/*
Minetest
Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>

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
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#include "content_mapblock.h"
#include "util/numeric.h"
#include "util/directiontables.h"
#include "mapblock_mesh.h"
#include "settings.h"
#include "nodedef.h"
#include "client/tile.h"
#include "mesh.h"
#include <IMeshManipulator.h>
#include "client.h"
#include "log.h"
#include "noise.h"
#include "util/cpp11.h"

// Distance of light extrapolation (for oversized nodes)
// After this distance, it gives up and considers light level constant
#define SMOOTH_LIGHTING_OVERSIZE 1.0

// Node edge count (for glasslike-framed)
#define FRAMED_EDGE_COUNT 12

// Node neighbor count, including edge-connected, but not vertex-connected
// (for glasslike-framed)
// Corresponding offsets are listed in g_27dirs
#define FRAMED_NEIGHBOR_COUNT 18

static constexpr v3s16 light_dirs[8] = {
	v3s16(-1, -1, -1),
	v3s16(-1, -1,  1),
	v3s16(-1,  1, -1),
	v3s16(-1,  1,  1),
	v3s16( 1, -1, -1),
	v3s16( 1, -1,  1),
	v3s16( 1,  1, -1),
	v3s16( 1,  1,  1),
};

// Standard index set to make a quad on 4 vertices
static constexpr u16 quad_indices[] = {0, 1, 2, 2, 3, 0};

const std::string MapblockMeshGenerator::raillike_groupname = "connect_to_raillike";

MapblockMeshGenerator::MapblockMeshGenerator(MeshMakeData *input, MeshCollector *output)
{
	data      = input;
	collector = output;

	nodedef   = data->m_client->ndef();
	smgr      = data->m_client->getSceneManager();
	meshmanip = smgr->getMeshManipulator();

	enable_mesh_cache = g_settings->getBool("enable_mesh_cache") &&
		!data->m_smooth_lighting; // Mesh cache is not supported with smooth lighting

	blockpos_nodes = data->m_blockpos * MAP_BLOCKSIZE;
}

void MapblockMeshGenerator::useTile(int index, bool disable_backface_culling)
{
	tile = getNodeTileN(n, p, index, data);
	if (!data->m_smooth_lighting)
		color = encode_light_and_color(light, tile.color, f->light_source);
	if (disable_backface_culling)
		tile.material_flags &= ~MATERIAL_FLAG_BACKFACE_CULLING;
	tile.material_flags |= MATERIAL_FLAG_CRACK_OVERLAY;
}

void MapblockMeshGenerator::useDefaultTile(bool set_color)
{
	tile = getNodeTile(n, p, v3s16(0, 0, 0), data);
	if (set_color && !data->m_smooth_lighting)
		color = encode_light_and_color(light, tile.color, f->light_source);
}

TileSpec MapblockMeshGenerator::getTile(const v3s16& direction)
{
	return getNodeTile(n, p, direction, data);
}

void MapblockMeshGenerator::drawQuad(v3f *coords, const v3s16 &normal)
{
	static const v2f tcoords[4] = {v2f(0, 0), v2f(1, 0), v2f(1, 1), v2f(0, 1)};
	video::S3DVertex vertices[4];
	bool shade_face = !f->light_source && (normal != v3s16(0, 0, 0));
	v3f normal2(normal.X, normal.Y, normal.Z);
	for (int j = 0; j < 4; j++) {
		vertices[j].Pos = coords[j] + origin;
		vertices[j].Normal = normal2;
		if (data->m_smooth_lighting)
			vertices[j].Color = blendLight(coords[j], tile.color);
		else
			vertices[j].Color = color;
		if (shade_face)
			applyFacesShading(vertices[j].Color, normal2);
		vertices[j].TCoords = tcoords[j];
	}
	collector->append(tile, vertices, 4, quad_indices, 6);
}

// Create a cuboid.
//  tiles     - the tiles (materials) to use (for all 6 faces)
//  tilecount - number of entries in tiles, 1<=tilecount<=6
//  lights    - vertex light levels. The order is the same as in light_dirs.
//              NULL may be passed if smooth lighting is disabled.
//  txc       - texture coordinates - this is a list of texture coordinates
//              for the opposite corners of each face - therefore, there
//              should be (2+2)*6=24 values in the list. The order of
//              the faces in the list is up-down-right-left-back-front
//              (compatible with ContentFeatures).
void MapblockMeshGenerator::drawCuboid(const aabb3f &box,
	TileSpec *tiles, int tilecount, const u16 *lights, const f32 *txc)
{
	assert(tilecount >= 1 && tilecount <= 6); // pre-condition

	v3f min = box.MinEdge;
	v3f max = box.MaxEdge;

	video::SColor colors[6];
	if (!data->m_smooth_lighting) {
		for (int face = 0; face != 6; ++face) {
			int tileindex = MYMIN(face, tilecount - 1);
			colors[face] = encode_light_and_color(light, tiles[tileindex].color, f->light_source);
		}
		if (!f->light_source) {
			applyFacesShading(colors[0], v3f(0, 1, 0));
			applyFacesShading(colors[1], v3f(0, -1, 0));
			applyFacesShading(colors[2], v3f(1, 0, 0));
			applyFacesShading(colors[3], v3f(-1, 0, 0));
			applyFacesShading(colors[4], v3f(0, 0, 1));
			applyFacesShading(colors[5], v3f(0, 0, -1));
		}
	}

	video::S3DVertex vertices[24] = {
		// top
		video::S3DVertex(min.X, max.Y, max.Z, 0, 1, 0, colors[0], txc[0], txc[1]),
		video::S3DVertex(max.X, max.Y, max.Z, 0, 1, 0, colors[0], txc[2], txc[1]),
		video::S3DVertex(max.X, max.Y, min.Z, 0, 1, 0, colors[0], txc[2], txc[3]),
		video::S3DVertex(min.X, max.Y, min.Z, 0, 1, 0, colors[0], txc[0], txc[3]),
		// bottom
		video::S3DVertex(min.X, min.Y, min.Z, 0, -1, 0, colors[1], txc[4], txc[5]),
		video::S3DVertex(max.X, min.Y, min.Z, 0, -1, 0, colors[1], txc[6], txc[5]),
		video::S3DVertex(max.X, min.Y, max.Z, 0, -1, 0, colors[1], txc[6], txc[7]),
		video::S3DVertex(min.X, min.Y, max.Z, 0, -1, 0, colors[1], txc[4], txc[7]),
		// right
		video::S3DVertex(max.X, max.Y, min.Z, 1, 0, 0, colors[2], txc[ 8], txc[9]),
		video::S3DVertex(max.X, max.Y, max.Z, 1, 0, 0, colors[2], txc[10], txc[9]),
		video::S3DVertex(max.X, min.Y, max.Z, 1, 0, 0, colors[2], txc[10], txc[11]),
		video::S3DVertex(max.X, min.Y, min.Z, 1, 0, 0, colors[2], txc[ 8], txc[11]),
		// left
		video::S3DVertex(min.X, max.Y, max.Z, -1, 0, 0, colors[3], txc[12], txc[13]),
		video::S3DVertex(min.X, max.Y, min.Z, -1, 0, 0, colors[3], txc[14], txc[13]),
		video::S3DVertex(min.X, min.Y, min.Z, -1, 0, 0, colors[3], txc[14], txc[15]),
		video::S3DVertex(min.X, min.Y, max.Z, -1, 0, 0, colors[3], txc[12], txc[15]),
		// back
		video::S3DVertex(max.X, max.Y, max.Z, 0, 0, 1, colors[4], txc[16], txc[17]),
		video::S3DVertex(min.X, max.Y, max.Z, 0, 0, 1, colors[4], txc[18], txc[17]),
		video::S3DVertex(min.X, min.Y, max.Z, 0, 0, 1, colors[4], txc[18], txc[19]),
		video::S3DVertex(max.X, min.Y, max.Z, 0, 0, 1, colors[4], txc[16], txc[19]),
		// front
		video::S3DVertex(min.X, max.Y, min.Z, 0, 0, -1, colors[5], txc[20], txc[21]),
		video::S3DVertex(max.X, max.Y, min.Z, 0, 0, -1, colors[5], txc[22], txc[21]),
		video::S3DVertex(max.X, min.Y, min.Z, 0, 0, -1, colors[5], txc[22], txc[23]),
		video::S3DVertex(min.X, min.Y, min.Z, 0, 0, -1, colors[5], txc[20], txc[23]),
	};

	static const u8 light_indices[24] = {
		3, 7, 6, 2,
		0, 4, 5, 1,
		6, 7, 5, 4,
		3, 2, 0, 1,
		7, 3, 1, 5,
		2, 6, 4, 0
	};

	for (int face = 0; face < 6; face++) {
		int tileindex = MYMIN(face, tilecount - 1);
		const TileSpec &tile = tiles[tileindex];
		for (int j = 0; j < 4; j++) {
			video::S3DVertex &vertex = vertices[face * 4 + j];
			v2f &tcoords = vertex.TCoords;
			switch (tile.rotation) {
			case 0:
				break;
			case 1: // R90
				tcoords.rotateBy(90, irr::core::vector2df(0, 0));
				break;
			case 2: // R180
				tcoords.rotateBy(180, irr::core::vector2df(0, 0));
				break;
			case 3: // R270
				tcoords.rotateBy(270, irr::core::vector2df(0, 0));
				break;
			case 4: // FXR90
				tcoords.X = 1.0 - tcoords.X;
				tcoords.rotateBy(90, irr::core::vector2df(0, 0));
				break;
			case 5: // FXR270
				tcoords.X = 1.0 - tcoords.X;
				tcoords.rotateBy(270, irr::core::vector2df(0, 0));
				break;
			case 6: // FYR90
				tcoords.Y = 1.0 - tcoords.Y;
				tcoords.rotateBy(90, irr::core::vector2df(0, 0));
				break;
			case 7: // FYR270
				tcoords.Y = 1.0 - tcoords.Y;
				tcoords.rotateBy(270, irr::core::vector2df(0, 0));
				break;
			case 8: // FX
				tcoords.X = 1.0 - tcoords.X;
				break;
			case 9: // FY
				tcoords.Y = 1.0 - tcoords.Y;
				break;
			default:
				break;
			}
		}
	}

	if (data->m_smooth_lighting) {
		for (int j = 0; j < 24; ++j) {
			int tileindex = MYMIN(j / 4, tilecount - 1);
			vertices[j].Color = encode_light_and_color(lights[light_indices[j]],
				tiles[tileindex].color, f->light_source);
			if (!f->light_source)
				applyFacesShading(vertices[j].Color, vertices[j].Normal);
		}
	}

	// Add to mesh collector
	for (int k = 0; k < 6; ++k) {
		int tileindex = MYMIN(k, tilecount - 1);
		collector->append(tiles[tileindex], vertices + 4 * k, 4, quad_indices, 6);
	}
}

// Gets the base lighting values for a node
void MapblockMeshGenerator::getSmoothLightFrame()
{
	for (int k = 0; k < 8; ++k) {
		u16 light = getSmoothLight(blockpos_nodes + p, light_dirs[k], data);
		frame.lightsA[k] = light & 0xff;
		frame.lightsB[k] = light >> 8;
	}
}

// Calculates vertex light level
//  vertex_pos - vertex position in the node (coordinates are clamped to [0.0, 1.0] or so)
u16 MapblockMeshGenerator::blendLight(const v3f &vertex_pos)
{
	f32 x = core::clamp(vertex_pos.X / BS + 0.5, 0.0 - SMOOTH_LIGHTING_OVERSIZE, 1.0 + SMOOTH_LIGHTING_OVERSIZE);
	f32 y = core::clamp(vertex_pos.Y / BS + 0.5, 0.0 - SMOOTH_LIGHTING_OVERSIZE, 1.0 + SMOOTH_LIGHTING_OVERSIZE);
	f32 z = core::clamp(vertex_pos.Z / BS + 0.5, 0.0 - SMOOTH_LIGHTING_OVERSIZE, 1.0 + SMOOTH_LIGHTING_OVERSIZE);
	f32 lightA = 0.0;
	f32 lightB = 0.0;
	for (int k = 0; k < 8; ++k) {
		f32 dx = (k & 4) ? x : 1 - x;
		f32 dy = (k & 2) ? y : 1 - y;
		f32 dz = (k & 1) ? z : 1 - z;
		lightA += dx * dy * dz * frame.lightsA[k];
		lightB += dx * dy * dz * frame.lightsB[k];
	}
	return
		core::clamp(core::round32(lightA), 0, 255) |
		core::clamp(core::round32(lightB), 0, 255) << 8;
}

// Calculates vertex color to be used in mapblock mesh
//  vertex_pos - vertex position in the node (coordinates are clamped to [0.0, 1.0] or so)
//  tile_color - node's tile color
video::SColor MapblockMeshGenerator::blendLight(const v3f &vertex_pos,
	video::SColor tile_color)
{
	u16 light = blendLight(vertex_pos);
	return encode_light_and_color(light, tile_color, f->light_source);
}

video::SColor MapblockMeshGenerator::blendLight(const v3f &vertex_pos,
	const v3f &vertex_normal, video::SColor tile_color)
{
	video::SColor color = blendLight(vertex_pos, tile_color);
	if (!f->light_source)
		applyFacesShading(color, vertex_normal);
	return color;
}

void MapblockMeshGenerator::generateCuboidTextureCoords(const aabb3f &box, f32 *coords)
{
	f32 tx1 = (box.MinEdge.X / BS) + 0.5;
	f32 ty1 = (box.MinEdge.Y / BS) + 0.5;
	f32 tz1 = (box.MinEdge.Z / BS) + 0.5;
	f32 tx2 = (box.MaxEdge.X / BS) + 0.5;
	f32 ty2 = (box.MaxEdge.Y / BS) + 0.5;
	f32 tz2 = (box.MaxEdge.Z / BS) + 0.5;
	f32 txc[24] = {
		    tx1, 1 - tz2,     tx2, 1 - tz1, // up
		    tx1,     tz1,     tx2,     tz2, // down
		    tz1, 1 - ty2,     tz2, 1 - ty1, // right
		1 - tz2, 1 - ty2, 1 - tz1, 1 - ty1, // left
		1 - tx2, 1 - ty2, 1 - tx1, 1 - ty1, // back
		    tx1, 1 - ty2,     tx2, 1 - ty1, // front
	};
	for (int i = 0; i != 24; ++i)
		coords[i] = txc[i];
}

void MapblockMeshGenerator::drawAutoLightedCuboid(aabb3f box, const f32 *txc,
	TileSpec *tiles, int tile_count)
{
	f32 texture_coord_buf[24];
	f32 dx1 = box.MinEdge.X;
	f32 dy1 = box.MinEdge.Y;
	f32 dz1 = box.MinEdge.Z;
	f32 dx2 = box.MaxEdge.X;
	f32 dy2 = box.MaxEdge.Y;
	f32 dz2 = box.MaxEdge.Z;
	box.MinEdge += origin;
	box.MaxEdge += origin;
	if (!txc) {
		generateCuboidTextureCoords(box, texture_coord_buf);
		txc = texture_coord_buf;
	}
	if (!tiles) {
		tiles = &tile;
		tile_count = 1;
	}
	if (data->m_smooth_lighting) {
		u16 lights[8];
		for (int j = 0; j < 8; ++j) {
			v3f d;
			d.X = (j & 4) ? dx2 : dx1;
			d.Y = (j & 2) ? dy2 : dy1;
			d.Z = (j & 1) ? dz2 : dz1;
			lights[j] = blendLight(d);
		}
		drawCuboid(box, tiles, tile_count, lights, txc);
	} else {
		drawCuboid(box, tiles, tile_count, NULL, txc);
	}
}

/*!
 * Returns the i-th special tile for a map node.
 */
static TileSpec getSpecialTile(const ContentFeatures &f,
	const MapNode &n, u8 i)
{
	TileSpec copy = f.special_tiles[i];
	if (!copy.has_color)
		n.getColor(f, &copy.color);
	return copy;
}

void MapblockMeshGenerator::prepareLiquidNodeDrawing(bool flowing)
{
	tile_liquid_top = getSpecialTile(*f, n, 0);
	tile_liquid = getSpecialTile(*f, n, flowing ? 1 : 0);

	MapNode ntop = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(p.X, p.Y + 1, p.Z));
	c_flowing = nodedef->getId(f->liquid_alternative_flowing);
	c_source = nodedef->getId(f->liquid_alternative_source);
	top_is_same_liquid = (ntop.getContent() == c_flowing) || (ntop.getContent() == c_source);

	if (data->m_smooth_lighting)
		return; // don't need to pre-compute anything in this case

	if (f->light_source != 0) {
		// If this liquid emits light and doesn't contain light, draw
		// it at what it emits, for an increased effect
		light = decode_light(f->light_source);
		light = light | (light << 8);
	} else if (nodedef->get(ntop).param_type == CPT_LIGHT) {
		// Otherwise, use the light of the node on top if possible
		light = getInteriorLight(ntop, 0, nodedef);
	}

	color_liquid_top = encode_light_and_color(light, tile_liquid_top.color, f->light_source);
	color = encode_light_and_color(light, tile_liquid.color, f->light_source);
}

void MapblockMeshGenerator::getLiquidNeighborhood(bool flowing)
{
	u8 range = rangelim(nodedef->get(c_flowing).liquid_range, 1, 8);

	for (int w = -1; w <= 1; w++)
	for (int u = -1; u <= 1; u++) {
		// Skip getting unneeded data
		if (!flowing && u && w)
			continue;

		NeighborData &neighbor = liquid_neighbors[w + 1][u + 1];
		v3s16 p2 = p + v3s16(u, 0, w);
		MapNode n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p2);
		neighbor.content = n2.getContent();
		neighbor.level = -0.5 * BS;
		neighbor.is_same_liquid = false;
		neighbor.top_is_same_liquid = false;

		if (neighbor.content == CONTENT_IGNORE)
			continue;

		if (neighbor.content == c_source) {
			neighbor.is_same_liquid = true;
			neighbor.level = 0.5 * BS;
		} else if (neighbor.content == c_flowing) {
			neighbor.is_same_liquid = true;
			u8 liquid_level = (n2.param2 & LIQUID_LEVEL_MASK);
			if (liquid_level <= LIQUID_LEVEL_MAX + 1 - range)
				liquid_level = 0;
			else
				liquid_level -= (LIQUID_LEVEL_MAX + 1 - range);
			neighbor.level = (-0.5 + (liquid_level + 0.5) / range) * BS;
		}

		// Check node above neighbor.
		// NOTE: This doesn't get executed if neighbor
		//       doesn't exist
		p2.Y++;
		n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p2);
		if (n2.getContent() == c_source || n2.getContent() == c_flowing)
			neighbor.top_is_same_liquid = true;
	}
}

void MapblockMeshGenerator::resetCornerLevels()
{
	for (int k = 0; k < 2; k++)
	for (int i = 0; i < 2; i++)
		corner_levels[k][i] = 0.5 * BS;
}

void MapblockMeshGenerator::calculateCornerLevels()
{
	for (int k = 0; k < 2; k++)
	for (int i = 0; i < 2; i++)
		corner_levels[k][i] = getCornerLevel(i, k);
}

f32 MapblockMeshGenerator::getCornerLevel(int i, int k)
{
	float sum = 0;
	int count = 0;
	int air_count = 0;
	for (int dk = 0; dk < 2; dk++)
	for (int di = 0; di < 2; di++) {
		NeighborData &neighbor_data = liquid_neighbors[k + dk][i + di];
		content_t content = neighbor_data.content;

		// If top is liquid, draw starting from top of node
		if (neighbor_data.top_is_same_liquid)
			return 0.5 * BS;

		// Source always has the full height
		if (content == c_source)
			return 0.5 * BS;

		// Flowing liquid has level information
		if (content == c_flowing) {
			sum += neighbor_data.level;
			count++;
		} else if (content == CONTENT_AIR) {
			air_count++;
			if (air_count >= 2)
				return -0.5 * BS + 0.2;
		}
	}
	if (count > 0)
		return sum / count;
	return 0;
}

void MapblockMeshGenerator::drawLiquidSides(bool flowing)
{
	struct LiquidFaceDesc {
		v3s16 dir; // XZ
		v3s16 p[2]; // XZ only; 1 means +, 0 means -
	};
	struct UV {
		int u, v;
	};
	static const LiquidFaceDesc base_faces[4] = {
		{v3s16( 1, 0,  0), {v3s16(1, 0, 1), v3s16(1, 0, 0)}},
		{v3s16(-1, 0,  0), {v3s16(0, 0, 0), v3s16(0, 0, 1)}},
		{v3s16( 0, 0,  1), {v3s16(0, 0, 1), v3s16(1, 0, 1)}},
		{v3s16( 0, 0, -1), {v3s16(1, 0, 0), v3s16(0, 0, 0)}},
	};
	static const UV base_vertices[4] = {
		{0, 1},
		{1, 1},
		{1, 0},
		{0, 0}
	};
	for (int i = 0; i < 4; i++) {
		const LiquidFaceDesc &face = base_faces[i];
		const NeighborData &neighbor = liquid_neighbors[face.dir.Z + 1][face.dir.X + 1];

		// No face between nodes of the same liquid, unless there is node
		// at the top to which it should be connected. Again, unless the face
		// there would be inside the liquid
		if (neighbor.is_same_liquid) {
			if (!flowing)
				continue;
			if (!top_is_same_liquid)
				continue;
			if (neighbor.top_is_same_liquid)
				continue;
		}

		if (!flowing && (neighbor.content == CONTENT_IGNORE))
			continue;

		const ContentFeatures &neighbor_features = nodedef->get(neighbor.content);
		// Don't draw face if neighbor is blocking the view
		if (neighbor_features.solidness == 2)
			continue;

		video::S3DVertex vertices[4];
		for (int j = 0; j < 4; j++) {
			const UV &vertex = base_vertices[j];
			const v3s16 &base = face.p[vertex.u];
			v3f pos;
			pos.X = (base.X - 0.5) * BS;
			pos.Z = (base.Z - 0.5) * BS;
			if (vertex.v)
				pos.Y = neighbor.is_same_liquid ? corner_levels[base.Z][base.X] : -0.5 * BS;
			else
				pos.Y =     !top_is_same_liquid ? corner_levels[base.Z][base.X] :  0.5 * BS;
			if (data->m_smooth_lighting)
				color = blendLight(pos, tile_liquid.color);
			pos += origin;
			vertices[j] = video::S3DVertex(pos.X, pos.Y, pos.Z, 0, 0, 0, color, vertex.u, vertex.v);
		};
		collector->append(tile_liquid, vertices, 4, quad_indices, 6);
	}
}

void MapblockMeshGenerator::drawLiquidTop(bool flowing)
{
	// To get backface culling right, the vertices need to go
	// clockwise around the front of the face. And we happened to
	// calculate corner levels in exact reverse order.
	static const int corner_resolve[4][2] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};

	video::S3DVertex vertices[4] = {
		video::S3DVertex(-BS / 2, 0,  BS / 2, 0, 0, 0, color_liquid_top, 0, 1),
		video::S3DVertex( BS / 2, 0,  BS / 2, 0, 0, 0, color_liquid_top, 1, 1),
		video::S3DVertex( BS / 2, 0, -BS / 2, 0, 0, 0, color_liquid_top, 1, 0),
		video::S3DVertex(-BS / 2, 0, -BS / 2, 0, 0, 0, color_liquid_top, 0, 0),
	};

	for (int i = 0; i < 4; i++) {
		int u = corner_resolve[i][0];
		int w = corner_resolve[i][1];
		vertices[i].Pos.Y += corner_levels[w][u];
		if (data->m_smooth_lighting)
			vertices[i].Color = blendLight(vertices[i].Pos, tile_liquid_top.color);
		vertices[i].Pos += origin;
	}

	if (flowing) {
		// Default downwards-flowing texture animation goes from
		// -Z towards +Z, thus the direction is +Z.
		// Rotate texture to make animation go in flow direction
		// Positive if liquid moves towards +Z
		f32 dz = (corner_levels[0][0] + corner_levels[0][1]) -
		         (corner_levels[1][0] + corner_levels[1][1]);
		// Positive if liquid moves towards +X
		f32 dx = (corner_levels[0][0] + corner_levels[1][0]) -
		         (corner_levels[0][1] + corner_levels[1][1]);
		f32 tcoord_angle = atan2(dz, dx) * core::RADTODEG;
		v2f tcoord_center(0.5, 0.5);
		v2f tcoord_translate(blockpos_nodes.Z + p.Z, blockpos_nodes.X + p.X);
		tcoord_translate.rotateBy(tcoord_angle);
		tcoord_translate.X -= floor(tcoord_translate.X);
		tcoord_translate.Y -= floor(tcoord_translate.Y);

		for (int i = 0; i < 4; i++) {
			vertices[i].TCoords.rotateBy(tcoord_angle, tcoord_center);
			vertices[i].TCoords += tcoord_translate;
		}

		std::swap(vertices[0].TCoords, vertices[2].TCoords);
	}

	collector->append(tile_liquid_top, vertices, 4, quad_indices, 6);
}

void MapblockMeshGenerator::drawLiquidNode(bool flowing)
{
	prepareLiquidNodeDrawing(flowing);
	getLiquidNeighborhood(flowing);
	if (flowing)
		calculateCornerLevels();
	else
		resetCornerLevels();
	drawLiquidSides(flowing);
	if (!top_is_same_liquid)
		drawLiquidTop(flowing);
}

void MapblockMeshGenerator::drawGlasslikeNode()
{
	useDefaultTile();

	for (int face = 0; face < 6; face++) {
		// Check this neighbor
		v3s16 dir = g_6dirs[face];
		v3s16 neighbor_pos = blockpos_nodes + p + dir;
		MapNode neighbor = data->m_vmanip.getNodeNoExNoEmerge(neighbor_pos);
		// Don't make face if neighbor is of same type
		if (neighbor.getContent() == n.getContent())
			continue;
		// Face at Z-
		v3f vertices[4] = {
			v3f(-BS / 2,  BS / 2, -BS / 2),
			v3f( BS / 2,  BS / 2, -BS / 2),
			v3f( BS / 2, -BS / 2, -BS / 2),
			v3f(-BS / 2, -BS / 2, -BS / 2),
		};
		for (int i = 0; i < 4; i++) {
			switch (face) {
				case D6D_ZP: vertices[i].rotateXZBy(180); break;
				case D6D_YP: vertices[i].rotateYZBy( 90); break;
				case D6D_XP: vertices[i].rotateXZBy( 90); break;
				case D6D_ZN: vertices[i].rotateXZBy(  0); break;
				case D6D_YN: vertices[i].rotateYZBy(-90); break;
				case D6D_XN: vertices[i].rotateXZBy(-90); break;
			}
		}
		drawQuad(vertices, dir);
	}
}

void MapblockMeshGenerator::drawGlasslikeFramedNode()
{
	TileSpec tiles[6];
	for (int face = 0; face < 6; face++)
		tiles[face] = getTile(g_6dirs[face]);

	TileSpec glass_tiles[6];
	if (tiles[0].texture && tiles[3].texture && tiles[4].texture) {
		glass_tiles[0] = tiles[4];
		glass_tiles[1] = tiles[0];
		glass_tiles[2] = tiles[4];
		glass_tiles[3] = tiles[4];
		glass_tiles[4] = tiles[3];
		glass_tiles[5] = tiles[4];
	} else {
		for (int face = 0; face < 6; face++)
			glass_tiles[face] = tiles[4];
	}

	u8 param2 = n.getParam2();
	bool H_merge = !(param2 & 128);
	bool V_merge = !(param2 & 64);
	param2 &= 63;

	static const float a = BS / 2;
	static const float g = a - 0.003;
	static const float b = .876 * ( BS / 2 );

	static const aabb3f frame_edges[FRAMED_EDGE_COUNT] = {
		aabb3f( b,  b, -a,  a,  a,  a), // y+
		aabb3f(-a,  b, -a, -b,  a,  a), // y+
		aabb3f( b, -a, -a,  a, -b,  a), // y-
		aabb3f(-a, -a, -a, -b, -b,  a), // y-
		aabb3f( b, -a,  b,  a,  a,  a), // x+
		aabb3f( b, -a, -a,  a,  a, -b), // x+
		aabb3f(-a, -a,  b, -b,  a,  a), // x-
		aabb3f(-a, -a, -a, -b,  a, -b), // x-
		aabb3f(-a,  b,  b,  a,  a,  a), // z+
		aabb3f(-a, -a,  b,  a, -b,  a), // z+
		aabb3f(-a, -a, -a,  a, -b, -b), // z-
		aabb3f(-a,  b, -a,  a,  a, -b), // z-
	};
	static const aabb3f glass_faces[6] = {
		aabb3f(-g, -g,  g,  g,  g,  g), // z+
		aabb3f(-g,  g, -g,  g,  g,  g), // y+
		aabb3f( g, -g, -g,  g,  g,  g), // x+
		aabb3f(-g, -g, -g,  g,  g, -g), // z-
		aabb3f(-g, -g, -g,  g, -g,  g), // y-
		aabb3f(-g, -g, -g, -g,  g,  g), // x-
	};

	// tables of neighbour (connect if same type and merge allowed),
	// checked with g_26dirs

	// 1 = connect, 0 = face visible
ofs	hex dump	ascii
0000	89 50 4e 47 0d 0a 1a 0a 00 00 00 0d 49 48 44 52 00 00 00 40 00 00 00 40 08 03 00 00 00 9d b7 81	.PNG........IHDR...@...@........
0020	ec 00 00 02 28 50 4c 54 45 00 00 00 ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff	....(PLTE.......................
0040	ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff	................................
0060	ff ff ff f3 f3 ff f4 f4 ff f4 f4 ff f5 f5 ff f6 f6 ff f6 f6 ff f7 f7 ff f7 f7 f7 f7 f7 f7 f7 f7	................................
0080	f8 f8 f8 f8 f8 f8 f8 f8 f8 f9 f9 f9 f9 f9 f9 f9 f9 f9 f9 f9 f9 f9 f9 f9 fa fa fa fa fa fa fa fa	................................
00a0	fa fa fa fa fa fa fa fa fa fa fb fb fb fb fb fb fb f7 f7 fb f7 f7 fb f7 f7 fb f7 f7 fb f8 f8 fc	................................
00c0	f8 f8 fc f8 f8 fc f8 f8 fc f8 f8 fc f9 f9 fc f9 f9 fc f9 f9 fc f9 f9 fc f9 f9 fc f9 f9 fc f9 f9	................................
00e0	fc fa fa fc fa fa fc fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa f8 f8 fa f8 f8 fa f8	................................
0100	f8 fa f8 f8 fa f8 f8 fb f8 f8 fb f8 f8 fb f8 f8 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb	................................
0120	f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9	................................
0140	fb f9 f9 fb fa fa fb fa fa fc fa fa fc fa fa fc fa fa fc f8 f8 fc f8 f8 fc f8 f8 fc f8 f8 fc f9	................................
0160	f9 fc f9 f9 fc f9 f9 fa f9 f9 fa f9 f9 fa f9 f9 fa f9 f9 fa f9 f9 fa f9 f9 fa f9 f9 fa f9 f9 fa	................................
0180	f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9	................................
01a0	fb fa fa fb fa fa fb fa fa fb fa fa fb f8 f8 fb f8 f8 fb f8 f8 fb f9 f9 fb f9 f9 fb f9 f9 fb f9	................................
01c0	f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb	................................
01e0	f9 f9 fb f9 f9 fb f9 f9 fc f9 f9 fc f9 f9 fc f9 f9 fc f9 f9 fa f9 f9 fa f9 f9 fa f9 f9 fb f9 f9	................................
0200	fb f9 f9 fb f9 f9 fb f9 f9 fb fa fa fb fa fa fb f8 f8 fb f8 f8 fb f9 f9 fb f9 f9 fb f9 f9 fb f9	................................
0220	f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb	................................
0240	f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 fb f9 f9 96 bd a9 12 00 00 00 b7 74 52 4e 53 00 01 02	.........................tRNS...
0260	03 04 05 06 07 08 09 0a 0b 0d 0e 0f 10 13 14 15 16 17 18 1a 1d 1e 1f 20 21 22 24 26 27 28 2a 2b	........................!"$&'(*+
0280	2c 2e 32 33 34 35 36 38 3b 3f 41 42 43 44 45 49 4a 4b 4c 4f 51 52 54 55 56 57 5d 5e 5f 61 63 66	,.234568;?ABCDEIJKLOQRTUVW]^_acf
02a0	67 69 6c 6d 6e 6f 71 72 73 75 76 77 78 7a 7c 7d 7e 7f 80 82 85 86 87 88 89 8a 8b 8f 91 92 93 94	gilmnoqrsuvwxz\|}~...............
02c0	95 96 98 9b 9d 9e 9f a0 a2 a3 a5 a6 a7 a8 a9 aa ac ad ae af b2 b3 b4 b6 b7 b8 ba bb bd bf c1 c3	................................
02e0	c4 c5 c8 c9 ca cc cd ce cf d1 d2 d3 d4 d5 d7 d8 d9 da db dc dd de e0 e1 e2 e3 e4 e5 e6 e8 e9 ea	................................
0300	eb ec ed ee ef f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe 14 69 8d 8b 00 00 02 94 49 44 41 54	.....................i......IDAT
0320	78 5e ed d3 e9 53 53 57 1c 87 f1 6f 20 a1 35 a8 58 d0 ba 5b 41 54 90 52 71 45 11 db 5a 6d ab a0	x^...SSW...o..5.X..[AT.RqE..Zm..
0340	b8 4b 5b 2b 6e 75 c3 1d 11 dc aa 2d b6 15 b5 a0 d8 0a ae 71 8f 82 5a 02 12 9e 7f cf 19 ce dc f1	.K[+nu.....-.......q..Z.........
0360	cc 21 24 f1 9d d3 c9 e7 dd 73 ef b9 77 e6 cc 39 3f 7d e0 52 52 52 d6 86 1e d6 8f f5 a2 fc 7a f8	.!$......s..w..9?}.RRR........z.
0380	52 be de 4b 11 40 c7 08 13 5f f5 03 7f eb 7d 0c af 01 60 99 a9 16 80 48 91 92 b7 f8 5e b8 0b a0	R..K.@..._....}...`....H....^...
03a0	dc e4 65 a0 2f 1c 3e 33 5a 49 f2 cf 0c 48 d9 65 67 98 65 fa 64 e7 d6 82 8f a4 ec cf 94 a4 71 95	..e./.>3ZI...H.eg.e.d.........q.
03c0	67 9b 2f d6 94 e8 8b cf 4d 57 8c ca 5e 75 a2 f9 cf da 79 7e 25 a5 aa 9b 01 57 a7 c9 f0 ad 37 4f	g./.....MW..^u....y~%....W....7O
03e0	b8 32 4d 49 d8 80 e7 45 a1 7c b9 63 a5 5a 3c e1 89 4a a8 e0 0d 1e ae a6 1d a3 ef 9b 22 de 69 4a	.2MI...E.\|.c.Z<..J..........".iJ
0400	57 02 c1 36 2c 47 81 9e d3 58 aa 94 c0 1e e2 7b 53 a8 b8 16 90 48 5b 50 71 e4 3c 22 a1 1d 8a e3	W..6,G...X.....{S....H[Pq.<"....
0420	08 ae fb af 71 44 8b 35 a4 72 1c 6d b9 f2 6f c2 71 67 a4 86 f0 e9 33 1c fb 24 4d c0 75 50 b1 f9	....qD.5.r.m..o.qg....3..$M.uP..
0440	ce 01 74 35 d5 35 75 61 d0 5f ff dd 96 10 9e de 1b cd ed 51 80 c5 8a 69 05 d0 32 3f 20 29 b0 a0	..t5.5ua._.........Q...i..2?.)..
0460	15 17 1d 5f 8e 90 94 53 f1 04 9e 8c 51 0c 93 5f c1 be 0c 19 19 fb 71 9c ca f4 36 7a 19 1a 35 58	..._...S....Q.._......q...6z..5X
0480	da 45 38 e8 93 c7 77 08 80 e8 dd fb 0c f8 3d 43 9e 4f 3a e0 6b 0d 32 1f 42 99 56 67 3e 00 7e 1e	.E8...w.......=C.O:.k.2.B.Vg>.~.
04a0	26 4d fd 17 e8 9e a0 77 66 43 c8 27 d7 5e 58 23 5b 15 5c 1f 58 56 0c 1c 90 ed 12 14 ca 75 0d 72	&M.....wfC.'.^X#[.\.XV.......u.r
04c0	65 cb 83 5f 06 22 3d 02 65 b2 6d 86 ef e5 7a 4e 34 20 5b 20 4a 8d 89 97 30 43 b6 a5 f0 93 5c 11	e.._."=.e.m...zN4.[.J...0C....\.
04e0	7a 7c b2 f9 22 de aa a7 30 dd fd c1 0e b9 6e 43 8e 6c 39 b0 d2 db 1d 8b 64 db 08 eb e4 3a 0f 4b	z\|.."...0.....nC.l9.....d....:.K
0500	dc c1 98 6b a2 01 f6 cb f6 57 ac cb 58 09 e7 64 fb 95 ff 82 26 96 3b c7 58 02 bd 59 72 8d eb 81	...k.....W..X..d....&.;.X..Yr...
0520	85 56 97 c2 61 19 a3 5f c3 05 bf 3c 59 ed d0 a0 c1 b6 43 e7 4c 79 0a 3a e9 9d ec 45 35 70 3c 28	.V..a.._...<Y.....C.Ly.:...E5p<(
0540	63 cc 1f d0 97 a7 c1 b2 6e 42 f7 2a 73 94 81 ca 6e 58 2b 4f 66 ab 3d 4c c0 16 c5 92 1f 06 6e 55	c.......nB.*s...nX+Of.=L......nU
0560	97 96 94 fe 70 0b 38 6e 9d ea 94 c7 00 bd 2d 17 6e 44 01 1a d3 14 d3 94 7f f0 d0 bf 2d 5d 96 89	....p.8n......-.nD..........-]..
0580	f6 7c ef f4 6b 08 1f 57 3c c4 7c 7e de bd eb 19 df 86 30 7e 2b 52 1c e9 73 7e ac ad db 55 31 3e	.\|..k..W<.\|~......0~+R..s~...U1>
05a0	d6 ab e2 ea 03 75 bb 57 4f d2 ff 54 4a 4a ca 5b f1 4c f0 28 0b 4c ee 89 00 00 00 00 49 45 4e 44	.....u.WO..TJJ.[.L.(.L......IEND
05c0	ae 42 60 82	.B`.