code:
/*
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)
{
	getNodeTileN(n, p, index, data, tile);
	if (!data->m_smooth_lighting)
		color = encode_light(light, f->light_source);
	for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
		tile.layers[layer].material_flags |= MATERIAL_FLAG_CRACK_OVERLAY;
		if (disable_backface_culling)
			tile.layers[layer].material_flags &= ~MATERIAL_FLAG_BACKFACE_CULLING;
	}
}

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

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

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 = blendLightColor(coords[j]);
		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) {
			colors[face] = encode_light(light, 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) {
			vertices[j].Color = encode_light(lights[light_indices[j]],
				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::blendLightColor(const v3f &vertex_pos)
{
	u16 light = blendLight(vertex_pos);
	return encode_light(light, f->light_source);
}

video::SColor MapblockMeshGenerator::blendLightColor(const v3f &vertex_pos,
	const v3f &vertex_normal)
{
	video::SColor color = blendLightColor(vertex_pos);
	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];
	for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++) {
		TileLayer *layer = &copy.layers[layernum];
		if (layer->texture_id == 0)
			continue;
		if (!layer->has_color)
			n.getColor(f, &(layer->color));
	}
	return copy;
}

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

	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(light, f->light_source);
	color = encode_light(light, f->light_source);
}

void MapblockMeshGenerator::getLiquidNeighborhood()
{
	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++) {
		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::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()
{
	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 (!top_is_same_liquid)
				continue;
			if (neighbor.top_is_same_liquid)
				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 = blendLightColor(pos);
			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()
{
	// 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 = blendLightColor(vertices[i].Pos);
		vertices[i].Pos += origin;
	}

	// 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()
{
	prepareLiquidNodeDrawing();
	getLiquidNeighborhood();
	calculateCornerLevels();
	drawLiquidSides();
	if (!top_is_same_liquid)
		drawLiquidTop();
}

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++)
		getTile(g_6dirs[face], tiles[face]);

	TileSpec glass_tiles[6];
	if (tiles[1].layers[0].texture &&
			tiles[2].layers[0].texture &&
			tiles[3].layers[0].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
	bool nb[FRAMED_NEIGHBOR_COUNT] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

	// 1 = check
	static const bool check_nb_vertical   [FRAMED_NEIGHBOR_COUNT] = {0,1,0,0,1,0, 0,0,0,0, 0,0,0,0, 0,0,0,0};
	static const bool check_nb_horizontal [FRAMED_NEIGHBOR_COUNT] = {1,0,1,1,0,1, 0,0,0,0, 1,1,1,1, 0,0,0,0};
	static const bool check_nb_all        [FRAMED_NEIGHBOR_COUNT] = {1,1,1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1};
	const bool *check_nb = check_nb_all;

	// neighbours checks for frames visibility
	if (H_merge || V_merge) {
		if (!H_merge)
			check_nb = check_nb_vertical; // vertical-only merge
		if (!V_merge)
			check_nb = check_nb_horizontal; // horizontal-only merge
		content_t current = n.getContent();
		for (int i = 0; i < FRAMED_NEIGHBOR_COUNT; i++) {
			if (!check_nb[i])
				continue;
			v3s16 n2p = blockpos_nodes + p + g_26dirs[i];
			MapNode n2 = data->m_vmanip.getNodeNoEx(n2p);
			content_t n2c = n2.getContent();
			if (n2c == current || n2c == CONTENT_IGNORE)
				nb[i] = 1;
		}
	}

	// edge visibility

	static const u8 nb_triplet[FRAMED_EDGE_COUNT][3] = {
		{1, 2,  7}, {1, 5,  6}, {4, 2, 15}, {4, 5, 14},
		{2, 0, 11}, {2, 3, 13}, {5, 0, 10}, {5, 3, 12},
		{0, 1,  8}, {0, 4, 16}, {3, 4, 17}, {3, 1,  9},
	};

	tile = tiles[1];
	for (int edge = 0; edge < FRAMED_EDGE_COUNT; edge++) {
		bool edge_invisible;
		if (nb[nb_triplet[edge][2]])
			edge_invisible = nb[nb_triplet[edge][0]] & nb[nb_triplet[edge][1]];
		else
			edge_invisible = nb[nb_triplet[edge][0]] ^ nb[nb_triplet[edge][1]];
		if (edge_invisible)
			continue;
		drawAutoLightedCuboid(frame_edges[edge]);
	}

	for (int face = 0; face < 6; face++) {
		if (nb[face])
			continue;
		tile = glass_tiles[face];
		drawAutoLightedCuboid(glass_faces[face]);
	}

	// Optionally render internal liquid level defined by param2
	// Liquid is textured with 1 tile defined in nodedef 'special_tiles'
	if (param2 > 0 && f->param_type_2 == CPT2_GLASSLIKE_LIQUID_LEVEL &&
			f->special_tiles[0].layers[0].texture) {
		// Internal liquid level has param2 range 0 .. 63,
		// convert it to -0.5 .. 0.5
		float vlev = (param2 / 63.0) * 2.0 - 1.0;
		tile = getSpecialTile(*f, n, 0);
		drawAutoLightedCuboid(aabb3f(-(nb[5] ? g : b),
		                             -(nb[4] ? g : b),
		                             -(nb[3] ? g : b),
		                              (nb[2] ? g : b),
		                              (nb[1] ? g : b) * vlev,
		                              (nb[0] ? g : b)));
	}
}

void MapblockMeshGenerator::drawAllfacesNode()
{
	static const aabb3f box(-BS / 2, -BS / 2, -BS / 2, BS / 2, BS / 2, BS / 2);
	useDefaultTile(false);
	drawAutoLightedCuboid(box);
}

void MapblockMeshGenerator::drawTorchlikeNode()
{
	u8 wall = n.getWallMounted(nodedef);
	u8 tileindex = 0;
	switch (wall) {
		case DWM_YP: tileindex = 1; break; // ceiling
		case DWM_YN: tileindex = 0; break; // floor
		default:     tileindex = 2; // side (or invalid—should we care?)
	}
	useTile(tileindex, true);

	float size = BS / 2 * f->visual_scale;
	v3f vertices[4] = {
		v3f(-size,  size, 0),
		v3f( size,  size, 0),
		v3f( size, -size, 0),
		v3f(-size, -size, 0),
	};
	for (int i = 0; i < 4; i++) {
		switch (wall) {
			case DWM_YP: vertices[i].rotateXZBy(-45); break;
			case DWM_YN: vertices[i].rotateXZBy( 45); break;
			case DWM_XP: vertices[i].rotateXZBy(  0); break;
			case DWM_XN: vertices[i].rotateXZBy(180); break;
			case DWM_ZP: vertices[i].rotateXZBy( 90); break;
			case DWM_ZN: vertices[i].rotateXZBy(-90); break;
		}
	}
	drawQuad(vertices);
}

void MapblockMeshGenerator::drawSignlikeNode()
{
	u8 wall = n.getWallMounted(nodedef);
	useTile(0, true);
	static const float offset = BS / 16;
	float size = BS / 2 * f->visual_scale;
	// Wall at X+ of node
	v3f vertices[4] = {
		v3f(BS / 2 - offset,  size,  size),
		v3f(BS / 2 - offset,  size, -size),
		v3f(BS / 2 - offset, -size, -size),
		v3f(BS / 2 - offset, -size,  size),
	};
	for (int i = 0; i < 4; i++) {
		switch (wall) {
			case DWM_YP: vertices[i].rotateXYBy( 90); break;
			case DWM_YN: vertices[i].rotateXYBy(-90); break;
			case DWM_XP: vertices[i].rotateXZBy(  0); break;
			case DWM_XN: vertices[i].rotateXZBy(180); break;
			case DWM_ZP: vertices[i].rotateXZBy( 90); break;
			case DWM_ZN: vertices[i].rotateXZBy(-90); break;
		}
	}
	drawQuad(vertices);
}

void MapblockMeshGenerator::drawPlantlikeQuad(float rotation, float quad_offset,
	bool offset_top_only)
{
	v3f vertices[4] = {
		v3f(-scale, -BS / 2 + scale * 2, 0),
		v3f( scale, -BS / 2 + scale * 2, 0),
		v3f( scale, -BS / 2, 0),
		v3f(-scale, -BS / 2, 0),
	};
	if (random_offset_Y) {
		PseudoRandom yrng(face_num++ | p.X << 16 | p.Z << 8 | p.Y << 24);
		offset.Y = BS * ((yrng.next() % 16 / 16.0) * 0.125);
	}
	int offset_count = offset_top_only ? 2 : 4;
	for (int i = 0; i < offset_count; i++)
		vertices[i].Z += quad_offset;
	for (int i = 0; i < 4; i++) {
		vertices[i].rotateXZBy(rotation + rotate_degree);
		vertices[i] += offset;
	}
	drawQuad(vertices);
}

void MapblockMeshGenerator::drawPlantlikeNode()
{
	useTile(0, false);
	draw_style = PLANT_STYLE_CROSS;
	scale = BS / 2 * f->visual_scale;
	offset = v3f(0, 0, 0);
	rotate_degree = 0;
	random_offset_Y = false;
	face_num = 0;

	switch (f->param_type_2) {
	case CPT2_MESHOPTIONS:
		draw_style = PlantlikeStyle(n.param2 & MO_MASK_STYLE);
		if (n.param2 & MO_BIT_SCALE_SQRT2)
			scale *= 1.41421;
		if (n.param2 & MO_BIT_RANDOM_OFFSET) {
			PseudoRandom rng(p.X << 8 | p.Z | p.Y << 16);
			offset.X = BS * ((rng.next() % 16 / 16.0) * 0.29 - 0.145);
			offset.Z = BS * ((rng.next() % 16 / 16.0) * 0.29 - 0.145);
		}
		if (n.param2 & MO_BIT_RANDOM_OFFSET_Y)
			random_offset_Y = true;
		break;

	case CPT2_DEGROTATE:
		rotate_degree = n.param2 * 2;
		break;

	default:
		break;
	}

	switch (draw_style) {
	case PLANT_STYLE_CROSS:
		drawPlantlikeQuad(46);
		drawPlantlikeQuad(-44);
		break;

	case PLANT_STYLE_CROSS2:
		drawPlantlikeQuad(91);
		drawPlantlikeQuad(1);
		break;

	case PLANT_STYLE_STAR:
		drawPlantlikeQuad(121);
		drawPlantlikeQuad(241);
		drawPlantlikeQuad(1);
		break;

	case PLANT_STYLE_HASH:
		drawPlantlikeQuad(  1, BS / 4);
		drawPlantlikeQuad( 91, BS / 4);
		drawPlantlikeQuad(181, BS / 4);
		drawPlantlikeQuad(271, BS / 4);
		break;

	case PLANT_STYLE_HASH2:
		drawPlantlikeQuad(  1, -BS / 2, true);
		drawPlantlikeQuad( 91, -BS / 2, true);
		drawPlantlikeQuad(181, -BS / 2, true);
		drawPlantlikeQuad(271, -BS / 2, true);
		break;
	}
}

void MapblockMeshGenerator::drawFirelikeQuad(float rotation, float opening_angle,
	float offset_h, float offset_v)
{
	v3f vertices[4] = {
		v3f(-scale, -BS / 2 + scale * 2, 0),
		v3f( scale, -BS / 2 + scale * 2, 0),
		v3f( scale, -BS / 2, 0),
		v3f(-scale, -BS / 2, 0),
	};
	for (int i = 0; i < 4; i++) {
		vertices[i].rotateYZBy(opening_angle);
		vertices[i].Z += offset_h;
		vertices[i].rotateXZBy(rotation);
		vertices[i].Y += offset_v;
	}
	drawQuad(vertices);
}

void MapblockMeshGenerator::drawFirelikeNode()
{
	useTile(0, false);
	scale = BS / 2 * f->visual_scale;

	// Check for adjacent nodes
	bool neighbors = false;
	bool neighbor[6] = {0, 0, 0, 0, 0, 0};
	content_t current = n.getContent();
	for (int i = 0; i < 6; i++) {
		v3s16 n2p = blockpos_nodes + p + g_6dirs[i];
		MapNode n2 = data->m_vmanip.getNodeNoEx(n2p);
		content_t n2c = n2.getContent();
		if (n2c != CONTENT_IGNORE && n2c != CONTENT_AIR && n2c != current) {
			neighbor[i] = true;
			neighbors = true;
		}
	}
	bool drawBasicFire = neighbor[D6D_YN] || !neighbors;
	bool drawBottomFire = neighbor[D6D_YP];

	if (drawBasicFire || neighbor[D6D_ZP])
		drawFirelikeQuad(0, -10, 0.4 * BS);
	else if (drawBottomFire)
		drawFirelikeQuad(0, 70, 0.47 * BS, 0.484 * BS);

	if (drawBasicFire || neighbor[D6D_XN])
		drawFirelikeQuad(90, -10, 0.4 * BS);
	else if (drawBottomFire)
		drawFirelikeQuad(90, 70, 0.47 * BS, 0.484 * BS);

	if (drawBasicFire || neighbor[D6D_ZN])
		drawFirelikeQuad(180, -10, 0.4 * BS);
	else if (drawBottomFire)
		drawFirelikeQuad(180, 70, 0.47 * BS, 0.484 * BS);

	if (drawBasicFire || neighbor[D6D_XP])
		drawFirelikeQuad(270, -10, 0.4 * BS);
	else if (drawBottomFire)
		drawFirelikeQuad(270, 70, 0.47 * BS, 0.484 * BS);

	if (drawBasicFire) {
		drawFirelikeQuad(45, 0, 0.0);
		drawFirelikeQuad(-45, 0, 0.0);
	}
}

void MapblockMeshGenerator::drawFencelikeNode()
{
	useDefaultTile(false);
	TileSpec tile_nocrack = tile;
	for (int layer = 0; layer < MAX_TILE_LAYERS; layer++)
		tile_nocrack.layers[layer].material_flags &= ~MATERIAL_FLAG_CRACK;

	// Put wood the right way around in the posts
	TileSpec tile_rot = tile;
	tile_rot.rotation = 1;

	static const f32 post_rad = BS / 8;
	static const f32 bar_rad  = BS / 16;
	static const f32 bar_len  = BS / 2 - post_rad;

	// The post - always present
	static const aabb3f post(-post_rad, -BS / 2, -post_rad,
	                          post_rad,  BS / 2,  post_rad);
	static const f32 postuv[24] = {
		0.375, 0.375, 0.625, 0.625,
		0.375, 0.375, 0.625, 0.625,
		0.000, 0.000, 0.250, 1.000,
		0.250, 0.000, 0.500, 1.000,
		0.500, 0.000, 0.750, 1.000,
		0.750, 0.000, 1.000, 1.000,
	};
	tile = tile_rot;
	drawAutoLightedCuboid(post, postuv);

	tile = tile_nocrack;

	// Now a section of fence, +X, if there's a post there
	v3s16 p2 = p;
	p2.X++;
	MapNode n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p2);
	const ContentFeatures *f2 = &nodedef->get(n2);
	if (f2->drawtype == NDT_FENCELIKE) {
		static const aabb3f bar_x1(BS / 2 - bar_len,  BS / 4 - bar_rad, -bar_rad,
		                           BS / 2 + bar_len,  BS / 4 + bar_rad,  bar_rad);
		static const aabb3f bar_x2(BS / 2 - bar_len, -BS / 4 - bar_rad, -bar_rad,
		                           BS / 2 + bar_len, -BS / 4 + bar_rad,  bar_rad);
		static const f32 xrailuv[24] = {
			0.000, 0.125, 1.000, 0.250,
			0.000, 0.250, 1.000, 0.375,
			0.375, 0.375, 0.500, 0.500,
			0.625, 0.625, 0.750, 0.750,
			0.000, 0.500, 1.000, 0.625,
			0.000, 0.875, 1.000, 1.000,
		};
		drawAutoLightedCuboid(bar_x1, xrailuv);
		drawAutoLightedCuboid(bar_x2, xrailuv);
	}

	// Now a section of fence, +Z, if there's a post there
	p2 = p;
	p2.Z++;
	n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p2);
	f2 = &nodedef->get(n2);
	if (f2->drawtype == NDT_FENCELIKE) {
		static const aabb3f bar_z1(-bar_rad,  BS / 4 - bar_rad, BS / 2 - bar_len,
		                            bar_rad,  BS / 4 + bar_rad, BS / 2 + bar_len);
		static const aabb3f bar_z2(-bar_rad, -BS / 4 - bar_rad, BS / 2 - bar_len,
		                            bar_rad, -BS / 4 + bar_rad, BS / 2 + bar_len);
		static const f32 zrailuv[24] = {
			0.1875, 0.0625, 0.3125, 0.3125, // cannot rotate; stretch
			0.2500, 0.0625, 0.3750, 0.3125, // for wood texture instead
			0.0000, 0.5625, 1.0000, 0.6875,
			0.0000, 0.3750, 1.0000, 0.5000,
			0.3750, 0.3750, 0.5000, 0.5000,
			0.6250, 0.6250, 0.7500, 0.7500,
		};
		drawAutoLightedCuboid(bar_z1, zrailuv);
		drawAutoLightedCuboid(bar_z2, zrailuv);
	}
}

bool MapblockMeshGenerator::isSameRail(v3s16 dir)
{
	MapNode node2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p + dir);
	if (node2.getContent() == n.getContent())
		return true;
	const ContentFeatures &def2 = nodedef->get(node2);
	return ((def2.drawtype == NDT_RAILLIKE) &&
		(def2.getGroup(raillike_groupname) == raillike_group));
}

void MapblockMeshGenerator::drawRaillikeNode()
{
	static const v3s16 direction[4] = {
		v3s16( 0, 0,  1),
		v3s16( 0, 0, -1),
		v3s16(-1, 0,  0),
		v3s16( 1, 0,  0),
	};
	static const int slope_angle[4] = {0, 180, 90, -90};

	enum RailTile {
		straight,
		curved,
		junction,
		cross,
	};
	struct RailDesc {
		int tile_index;
		int angle;
	};
	static const RailDesc rail_kinds[16] = {
		                   // +x -x -z +z
		                   //-------------
		{straight,   0}, //  .  .  .  .
		{straight,   0}, //  .  .  . +Z
		{straight,   0}, //  .  . -Z  .
		{straight,   0}, //  .  . -Z +Z
		{straight,  90}, //  . -X  .  .
		{  curved, 180}, //  . -X  . +Z
		{  curved, 270}, //  . -X -Z  .
		{junction, 180}, //  . -X -Z +Z
		{straight,  90}, // +X  .  .  .
		{  curved,  90}, // +X  .  . +Z
		{  curved,   0}, // +X  . -Z  .
		{junction,   0}, // +X  . -Z +Z
		{straight,  90}, // +X -X  .  .
		{junction,  90}, // +X -X  . +Z
		{junction, 270}, // +X -X -Z  .
		{   cross,   0}, // +X -X -Z +Z
	};

	raillike_group = nodedef->get(n).getGroup(raillike_groupname);

	int code = 0;
	int angle;
	int tile_index;
	bool sloped = false;
	for (int dir = 0; dir < 4; dir++) {
		bool rail_above = isSameRail(direction[dir] + v3s16(0, 1, 0));
		if (rail_above) {
			sloped = true;
			angle = slope_angle[dir];
		}
		if (rail_above ||
				isSameRail(direction[dir]) ||
				isSameRail(direction[dir] + v3s16(0, -1, 0)))
			code |= 1 << dir;
	}

	if (sloped) {
		tile_index = straight;
	} else {
		tile_index = rail_kinds[code].tile_index;
		angle = rail_kinds[code].angle;
	}

	useTile(tile_index, true);

	static const float offset = BS / 64;
	static const float size   = BS / 2;
	float y2 = sloped ? size : -size;
	v3f vertices[4] = {
		v3f(-size,    y2 + offset,  size),
		v3f( size,    y2 + offset,  size),
		v3f( size, -size + offset, -size),
		v3f(-size, -size + offset, -size),
	};
	if (angle)
		for (int i = 0; i < 4; i++)
			vertices[i].rotateXZBy(angle);
	drawQuad(vertices);
}

void MapblockMeshGenerator::drawNodeboxNode()
{
	static const v3s16 tile_dirs[6] = {
		v3s16(0, 1, 0),
		v3s16(0, -1, 0),
		v3s16(1, 0, 0),
		v3s16(-1, 0, 0),
		v3s16(0, 0, 1),
		v3s16(0, 0, -1)
	};

	// we have this order for some reason...
	static const v3s16 connection_dirs[6] = {
		v3s16( 0,  1,  0), // top
		v3s16( 0, -1,  0), // bottom
		v3s16( 0,  0, -1), // front
		v3s16(-1,  0,  0), // left
		v3s16( 0,  0,  1), // back
		v3s16( 1,  0,  0), // right
	};

	TileSpec tiles[6];
	for (int face = 0; face < 6; face++) {
		// Handles facedir rotation for textures
		getTile(tile_dirs[face], tiles[face]);
	}

	// locate possible neighboring nodes to connect to
	int neighbors_set = 0;
	if (f->node_box.type == NODEBOX_CONNECTED) {
		for (int dir = 0; dir != 6; dir++) {
			int flag = 1 << dir;
			v3s16 p2 = blockpos_nodes + p + connection_dirs[dir];
			MapNode n2 = data->m_vmanip.getNodeNoEx(p2);
			if (nodedef->nodeboxConnects(n, n2, flag))
				neighbors_set |= flag;
		}
	}

	std::vector<aabb3f> boxes;
	n.getNodeBoxes(nodedef, &boxes, neighbors_set);
	for (std::vector<aabb3f>::iterator i = boxes.begin(); i != boxes.end(); ++i)
		drawAutoLightedCuboid(*i, NULL, tiles, 6);
}

void MapblockMeshGenerator::drawMeshNode()
{
	u8 facedir = 0;
	scene::IMesh* mesh;
	bool private_mesh; // as a grab/drop pair is not thread-safe

	if (f->param_type_2 == CPT2_FACEDIR ||
			f->param_type_2 == CPT2_COLORED_FACEDIR) {
		facedir = n.getFaceDir(nodedef);
	} else if (f->param_type_2 == CPT2_WALLMOUNTED ||
			f->param_type_2 == CPT2_COLORED_WALLMOUNTED) {
		// Convert wallmounted to 6dfacedir.
		// When cache enabled, it is already converted.
		facedir = n.getWallMounted(nodedef);
		if (!enable_mesh_cache) {
			static const u8 wm_to_6d[6] = {20, 0, 16 + 1, 12 + 3, 8, 4 + 2};
			facedir = wm_to_6d[facedir];
		}
	}

	if (!data->m_smooth_lighting && f->mesh_ptr[facedir]) {
		// use cached meshes
		private_mesh = false;
		mesh = f->mesh_ptr[facedir];
	} else if (f->mesh_ptr[0]) {
		// no cache, clone and rotate mesh
		private_mesh = true;
		mesh = cloneMesh(f->mesh_ptr[0]);
		rotateMeshBy6dFacedir(mesh, facedir);
		recalculateBoundingBox(mesh);
		meshmanip->recalculateNormals(mesh, true, false);
	} else
		return;

	int mesh_buffer_count = mesh->getMeshBufferCount();
	for (int j = 0; j < mesh_buffer_count; j++) {
		useTile(j, false);
		scene::IMeshBuffer *buf = mesh->getMeshBuffer(j);
		video::S3DVertex *vertices = (video::S3DVertex *)buf->getVertices();
		int vertex_count = buf->getVertexCount();

		if (data->m_smooth_lighting) {
			// Mesh is always private here. So the lighting is applied to each
			// vertex right here.
			for (int k = 0; k < vertex_count; k++) {
				video::S3DVertex &vertex = vertices[k];
				vertex.Color = blendLightColor(vertex.Pos, vertex.Normal);
				vertex.Pos += origin;
			}
			collector->append(tile, vertices, vertex_count,
				buf->getIndices(), buf->getIndexCount());
		} else {
			// Don't modify the mesh, it may not be private here.
			// Instead, let the collector process colors, etc.
			collector->append(tile, vertices, vertex_count,
				buf->getIndices(), buf->getIndexCount(), origin,
				color, f->light_source);
		}
	}
	if (private_mesh)
		mesh->drop();
}

// also called when the drawtype is known but should have been pre-converted
void MapblockMeshGenerator::errorUnknownDrawtype()
{
	infostream << "Got drawtype " << f->drawtype << std::endl;
	FATAL_ERROR("Unknown drawtype");
}

void MapblockMeshGenerator::drawNode()
{
	if (data->m_smooth_lighting)
		getSmoothLightFrame();
	else
		light = getInteriorLight(n, 1, nodedef);
	switch (f->drawtype) {
		case NDT_FLOWINGLIQUID:     drawLiquidNode(); break;
		case NDT_GLASSLIKE:         drawGlasslikeNode(); break;
		case NDT_GLASSLIKE_FRAMED:  drawGlasslikeFramedNode(); break;
		case NDT_ALLFACES:          drawAllfacesNode(); break;
		case NDT_TORCHLIKE:         drawTorchlikeNode(); break;
		case NDT_SIGNLIKE:          drawSignlikeNode(); break;
		case NDT_PLANTLIKE:         drawPlantlikeNode(); break;
		case NDT_FIRELIKE:          drawFirelikeNode(); break;
		case NDT_FENCELIKE:         drawFencelikeNode(); break;
		case NDT_RAILLIKE:          drawRaillikeNode(); break;
		case NDT_NODEBOX:           drawNodeboxNode(); break;
		case NDT_MESH:              drawMeshNode(); break;
		default:                    errorUnknownDrawtype(); break;
	}
}

/*
	TODO: Fix alpha blending for special nodes
	Currently only the last element rendered is blended correct
*/
void MapblockMeshGenerator::generate()
{
	for (p.Z = 0; p.Z < MAP_BLOCKSIZE; p.Z++)
	for (p.Y = 0; p.Y < MAP_BLOCKSIZE; p.Y++)
	for (p.X = 0; p.X < MAP_BLOCKSIZE; p.X++) {
		n = data->m_vmanip.getNodeNoEx(blockpos_nodes + p);
		f = &nodedef->get(n);
		// Solid nodes are drawn by MapBlockMesh
		if (f->solidness != 0)
			continue;
		if (f->drawtype == NDT_AIRLIKE)
			continue;
		origin = intToFloat(p, BS);
		drawNode();
	}
}


code:
/*
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.
*/

#ifndef CONTENT_MAPBLOCK_HEADER
#define CONTENT_MAPBLOCK_HEADER
#include "util/numeric.h"
#include "nodedef.h"
#include <IMeshManipulator.h>

struct MeshMakeData;
struct MeshCollector;

struct LightFrame
{
	f32 lightsA[8];
	f32 lightsB[8];
};

class MapblockMeshGenerator
{
public:
	MeshMakeData *data;
	MeshCollector *collector;

	INodeDefManager *nodedef;
	scene::ISceneManager *smgr;
	scene::IMeshManipulator *meshmanip;

// options
	bool enable_mesh_cache;

// current node
	v3s16 blockpos_nodes;
	v3s16 p;
	v3f origin;
	MapNode n;
	const ContentFeatures *f;
	u16 light;
	LightFrame frame;
	video::SColor color;
	TileSpec tile;
	float scale;

// lighting
	void getSmoothLightFrame();
	u16 blendLight(const v3f &vertex_pos);
	video::SColor blendLightColor(const v3f &vertex_pos);
	video::SColor blendLightColor(const v3f &vertex_pos, const v3f &vertex_normal);

	void useTile(int index, bool disable_backface_culling);
	void useDefaultTile(bool set_color = true);
	void getTile(const v3s16 &direction, TileSpec &tile);

// face drawing
	void drawQuad(v3f *vertices, const v3s16 &normal = v3s16(0, 0, 0));

// cuboid drawing!
	void drawCuboid(const aabb3f &box, TileSpec *tiles, int tilecount,
		const u16 *lights , const f32 *txc);
	void generateCuboidTextureCoords(aabb3f const &box, f32 *coords);
	void drawAutoLightedCuboid(aabb3f box, const f32 *txc = NULL,
		TileSpec *tiles = NULL, int tile_count = 0);

// liquid-specific
	bool top_is_same_liquid;
	TileSpec tile_liquid;
	TileSpec tile_liquid_top;
	content_t c_flowing;
	content_t c_source;
	video::SColor color_liquid_top;
	struct NeighborData {
		f32 level;
		content_t content;
		bool is_same_liquid;
		bool top_is_same_liquid;
	};
	NeighborData liquid_neighbors[3][3];
	f32 corner_levels[2][2];

	void prepareLiquidNodeDrawing();
	void getLiquidNeighborhood();
	void calculateCornerLevels();
	f32 getCornerLevel(int i, int k);
	void drawLiquidSides();
	void drawLiquidTop();

// raillike-specific
	// name of the group that enables connecting to raillike nodes of different kind
	static const std::string raillike_groupname;
	int raillike_group;
	bool isSameRail(v3s16 dir);

// plantlike-specific
	PlantlikeStyle draw_style;
	v3f offset;
	int rotate_degree;
	bool random_offset_Y;
	int face_num;

	void drawPlantlikeQuad(float rotation, float quad_offset = 0,
		bool offset_top_only = false);

// firelike-specific
	void drawFirelikeQuad(float rotation, float opening_angle,
		float offset_h, float offset_v = 0.0);

// drawtypes
	void drawLiquidNode();
	void drawGlasslikeNode();
	void drawGlasslikeFramedNode();
	void drawAllfacesNode();
	void drawTorchlikeNode();
	void drawSignlikeNode();
	void drawPlantlikeNode();
	void drawFirelikeNode();
	void drawFencelikeNode();
	void drawRaillikeNode();
	void drawNodeboxNode();
	void drawMeshNode();

// common
	void errorUnknownDrawtype();
	void drawNode();

public:
	MapblockMeshGenerator(MeshMakeData *input, MeshCollector *output);
	void generate();
};

#endif

repo_name: pgimeno/minetest

license: unknown


code:
/*
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_mapnode.h"

#include "irrlichttypes_bloated.h"
#include "mapnode.h"
#include "nodedef.h"
#include "nameidmapping.h"
#include "util/string.h"

/*
	Legacy node content type IDs
	Ranges:
	0x000...0x07f (0...127): param2 is fully usable
	126 and 127 are reserved (CONTENT_AIR and CONTENT_IGNORE).
	0x800...0xfff (2048...4095): higher 4 bits of param2 are not usable
*/
#define CONTENT_STONE 0
#define CONTENT_WATER 2
#define CONTENT_TORCH 3
#define CONTENT_WATERSOURCE 9
#define CONTENT_SIGN_WALL 14
#define CONTENT_CHEST 15
#define CONTENT_FURNACE 16
#define CONTENT_LOCKABLE_CHEST 17
#define CONTENT_FENCE 21
#define CONTENT_RAIL 30
#define CONTENT_LADDER 31
#define CONTENT_LAVA 32
#define CONTENT_LAVASOURCE 33
#define CONTENT_GRASS 0x800 //1
#define CONTENT_TREE 0x801 //4
#define CONTENT_LEAVES 0x802 //5
#define CONTENT_GRASS_FOOTSTEPS 0x803 //6
#define CONTENT_MESE 0x804 //7
#define CONTENT_MUD 0x805 //8
#define CONTENT_CLOUD 0x806 //10
#define CONTENT_COALSTONE 0x807 //11
#define CONTENT_WOOD 0x808 //12
#define CONTENT_SAND 0x809 //13
#define CONTENT_COBBLE 0x80a //18
#define CONTENT_STEEL 0x80b //19
#define CONTENT_GLASS 0x80c //20
#define CONTENT_MOSSYCOBBLE 0x80d //22
#define CONTENT_GRAVEL 0x80e //23
#define CONTENT_SANDSTONE 0x80f //24
#define CONTENT_CACTUS 0x810 //25
#define CONTENT_BRICK 0x811 //26
#define CONTENT_CLAY 0x812 //27
#define CONTENT_PAPYRUS 0x813 //28
#define CONTENT_BOOKSHELF 0x814 //29
#define CONTENT_JUNGLETREE 0x815
#define CONTENT_JUNGLEGRASS 0x816
#define CONTENT_NC 0x817
#define CONTENT_NC_RB 0x818
#define CONTENT_APPLE 0x819
#define CONTENT_SAPLING 0x820

/*
	A conversion table for backwards compatibility.
	Maps <=v19 content types to current ones.
	Should never be touched.
*/
content_t trans_table_19[21][2] = {
	{CONTENT_GRASS, 1},
	{CONTENT_TREE, 4},
	{CONTENT_LEAVES, 5},
	{CONTENT_GRASS_FOOTSTEPS, 6},
	{CONTENT_MESE, 7},
	{CONTENT_MUD, 8},
	{CONTENT_CLOUD, 10},
	{CONTENT_COALSTONE, 11},
	{CONTENT_WOOD, 12},
	{CONTENT_SAND, 13},
	{CONTENT_COBBLE, 18},
	{CONTENT_STEEL, 19},
	{CONTENT_GLASS, 20},
	{CONTENT_MOSSYCOBBLE, 22},
	{CONTENT_GRAVEL, 23},
	{CONTENT_SANDSTONE, 24},
	{CONTENT_CACTUS, 25},
	{CONTENT_BRICK, 26},
	{CONTENT_CLAY, 27},
	{CONTENT_PAPYRUS, 28},
	{CONTENT_BOOKSHELF, 29},
};

MapNode mapnode_translate_to_internal(MapNode n_from, u8 version)
{
	MapNode result = n_from;
	if(version <= 19)
	{
		content_t c_from = n_from.getContent();
		for(u32 i=0; i<sizeof(trans_table_19)/sizeof(trans_table_19[0]); i++)
		{
			if(trans_table_19[i][1] == c_from)
			{
				result.setContent(trans_table_19[i][0]);
				break;
			}
		}
	}
	return result;
}

void content_mapnode_get_name_id_mapping(NameIdMapping *nimap)
{
	nimap->set(0, "default:stone");
	nimap->set(2, "default:water_flowing");
	nimap->set(3, "default:torch");
	nimap->set(9, "default:water_source");
	nimap->set(14, "default:sign_wall");
	nimap->set(15, "default:chest");
	nimap->set(16, "default:furnace");
	nimap->set(17, "default:chest_locked");
	nimap->set(21, "default:fence_wood");
	nimap->set(30, "default:rail");
	nimap->set(31, "default:ladder");
	nimap->set(32, "default:lava_flowing");
	nimap->set(33, "default:lava_source");
	nimap->set(0x800, "default:dirt_with_grass");
	nimap->set(0x801, "default:tree");
	nimap->set(0x802, "default:leaves");
	nimap->set(0x803, "default:dirt_with_grass_footsteps");
	nimap->set(0x804, "default:mese");
	nimap->set(0x805, "default:dirt");
	nimap->set(0x806, "default:cloud");
	nimap->set(0x807, "default:coalstone");
	nimap->set(0x808, "default:wood");
	nimap->set(0x809, "default:sand");
	nimap->set(0x80a, "default:cobble");
	nimap->set(0x80b, "default:steelblock");
	nimap->set(0x80c, "default:glass");
	nimap->set(0x80d, "default:mossycobble");
	nimap->set(0x80e, "default:gravel");
	nimap->set(0x80f, "default:sandstone");
	nimap->set(0x810, "default:cactus");
	nimap->set(0x811, "default:brick");
	nimap->set(0x812, "default:clay");
	nimap->set(0x813, "default:papyrus");
	nimap->set(0x814, "default:bookshelf");
	nimap->set(0x815, "default:jungletree");
	nimap->set(0x816, "default:junglegrass");
	nimap->set(0x817, "default:nyancat");
	nimap->set(0x818, "default:nyancat_rainbow");
	nimap->set(0x819, "default:apple");
	nimap->set(0x820, "default:sapling");
	// Static types
	nimap->set(CONTENT_IGNORE, "ignore");
	nimap->set(CONTENT_AIR, "air");
}


code:
/*
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.
*/

#ifndef CONTENT_MAPNODE_HEADER
#define CONTENT_MAPNODE_HEADER

#include "mapnode.h"

/*
	Legacy node definitions
*/

// Backwards compatibility for non-extended content types in v19
extern content_t trans_table_19[21][2];
MapNode mapnode_translate_to_internal(MapNode n_from, u8 version);

// Get legacy node name mapping for loading old blocks
class NameIdMapping;
void content_mapnode_get_name_id_mapping(NameIdMapping *nimap);

#endif


code:
/*
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_nodemeta.h"
#include "nodemetadata.h"
#include "nodetimer.h"
#include "inventory.h"
#include "log.h"
#include "serialization.h"
#include "util/serialize.h"
#include "util/string.h"
#include "constants.h" // MAP_BLOCKSIZE
#include <sstream>

#define NODEMETA_GENERIC 1
#define NODEMETA_SIGN 14
#define NODEMETA_CHEST 15
#define NODEMETA_FURNACE 16
#define NODEMETA_LOCKABLE_CHEST 17

// Returns true if node timer must be set
static bool content_nodemeta_deserialize_legacy_body(
		std::istream &is, s16 id, NodeMetadata *meta)
{
	meta->clear();

	if(id == NODEMETA_GENERIC) // GenericNodeMetadata (0.4-dev)
	{
		meta->getInventory()->deSerialize(is);
		deSerializeLongString(is);  // m_text
		deSerializeString(is);  // m_owner

		meta->setString("infotext",deSerializeString(is));
		meta->setString("formspec",deSerializeString(is));
		readU8(is);  // m_allow_text_input
		readU8(is);  // m_allow_removal
		readU8(is);  // m_enforce_owner

		int num_vars = readU32(is);
		for(int i=0; i<num_vars; i++){
			std::string name = deSerializeString(is);
			std::string var = deSerializeLongString(is);
			meta->setString(name, var);
		}
		return false;
	}
	else if(id == NODEMETA_SIGN) // SignNodeMetadata
	{
		meta->setString("text", deSerializeString(is));
		//meta->setString("infotext","\"${text}\"");
		meta->setString("infotext",
				std::string("\"") + meta->getString("text") + "\"");
		meta->setString("formspec","field[text;;${text}]");
		return false;
	}
	else if(id == NODEMETA_CHEST) // ChestNodeMetadata
	{
		meta->getInventory()->deSerialize(is);

		// Rename inventory list "0" to "main"
		Inventory *inv = meta->getInventory();
		if(!inv->getList("main") && inv->getList("0")){
			inv->getList("0")->setName("main");
		}
		assert(inv->getList("main") && !inv->getList("0"));

		meta->setString("formspec","size[8,9]"
				"list[current_name;main;0,0;8,4;]"
				"list[current_player;main;0,5;8,4;]");
		return false;
	}
	else if(id == NODEMETA_LOCKABLE_CHEST) // LockingChestNodeMetadata
	{
		meta->setString("owner", deSerializeString(is));
		meta->getInventory()->deSerialize(is);

		// Rename inventory list "0" to "main"
		Inventory *inv = meta->getInventory();
		if(!inv->getList("main") && inv->getList("0")){
			inv->getList("0")->setName("main");
		}
		assert(inv->getList("main") && !inv->getList("0"));

		meta->setString("formspec","size[8,9]"
				"list[current_name;main;0,0;8,4;]"
				"list[current_player;main;0,5;8,4;]");
		return false;
	}
	else if(id == NODEMETA_FURNACE) // FurnaceNodeMetadata
	{
		meta->getInventory()->deSerialize(is);
		int temp = 0;
		is>>temp;
		meta->setString("fuel_totaltime", ftos((float)temp/10));
		temp = 0;
		is>>temp;
		meta->setString("fuel_time", ftos((float)temp/10));
		temp = 0;
		is>>temp;
		//meta->setString("src_totaltime", ftos((float)temp/10));
		temp = 0;
		is>>temp;
		meta->setString("src_time", ftos((float)temp/10));

		meta->setString("formspec","size[8,9]"
			"list[current_name;fuel;2,3;1,1;]"
			"list[current_name;src;2,1;1,1;]"
			"list[current_name;dst;5,1;2,2;]"
			"list[current_player;main;0,5;8,4;]");
		return true;
	}
	else
	{
		throw SerializationError("Unknown legacy node metadata");
	}
}

static bool content_nodemeta_deserialize_legacy_meta(
		std::istream &is, NodeMetadata *meta)
{
	// Read id
	s16 id = readS16(is);

	// Read data
	std::string data = deSerializeString(is);
	std::istringstream tmp_is(data, std::ios::binary);
	return content_nodemeta_deserialize_legacy_body(tmp_is, id, meta);
}

void content_nodemeta_deserialize_legacy(std::istream &is,
		NodeMetadataList *meta, NodeTimerList *timers,
		IItemDefManager *item_def_mgr)
{
	meta->clear();
	timers->clear();

	u16 version = readU16(is);

	if(version > 1)
	{
		infostream<<FUNCTION_NAME<<": version "<<version<<" not supported"
				<<std::endl;
		throw SerializationError(FUNCTION_NAME);
	}

	u16 count = readU16(is);

	for(u16 i=0; i<count; i++)
	{
		u16 p16 = readU16(is);

		v3s16 p(0,0,0);
		p.Z += p16 / MAP_BLOCKSIZE / MAP_BLOCKSIZE;
		p16 -= p.Z * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
		p.Y += p16 / MAP_BLOCKSIZE;
		p16 -= p.Y * MAP_BLOCKSIZE;
		p.X += p16;

		if(meta->get(p) != NULL)
		{
			warningstream<<FUNCTION_NAME<<": "
					<<"already set data at position"
					<<"("<<p.X<<","<<p.Y<<","<<p.Z<<"): Ignoring."
					<<std::endl;
			continue;
		}

		NodeMetadata *data = new NodeMetadata(item_def_mgr);
		bool need_timer = content_nodemeta_deserialize_legacy_meta(is, data);
		meta->set(p, data);

		if(need_timer)
			timers->set(NodeTimer(1., 0., p));
	}
}

void content_nodemeta_serialize_legacy(std::ostream &os, NodeMetadataList *meta)
{
	// Sorry, I was too lazy to implement this. --kahrl
	writeU16(os, 1); // version
	writeU16(os, 0); // count
}

// END


code:
/*
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.
*/

#ifndef CONTENT_NODEMETA_HEADER
#define CONTENT_NODEMETA_HEADER

#include <iostream>

class NodeMetadataList;
class NodeTimerList;
class IItemDefManager;

/*
	Legacy nodemeta definitions
*/

void content_nodemeta_deserialize_legacy(std::istream &is,
		NodeMetadataList *meta, NodeTimerList *timers,
		IItemDefManager *item_def_mgr);

void content_nodemeta_serialize_legacy(std::ostream &os, NodeMetadataList *meta);

#endif


code:
/*
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_sao.h"
#include "util/serialize.h"
#include "collision.h"
#include "environment.h"
#include "tool.h" // For ToolCapabilities
#include "gamedef.h"
#include "nodedef.h"
#include "remoteplayer.h"
#include "server.h"
#include "scripting_server.h"
#include "genericobject.h"

std::map<u16, ServerActiveObject::Factory> ServerActiveObject::m_types;

/*
	TestSAO
*/

class TestSAO : public ServerActiveObject
{
public:
	TestSAO(ServerEnvironment *env, v3f pos):
		ServerActiveObject(env, pos),
		m_timer1(0),
		m_age(0)
	{
		ServerActiveObject::registerType(getType(), create);
	}
	ActiveObjectType getType() const
	{ return ACTIVEOBJECT_TYPE_TEST; }

	static ServerActiveObject* create(ServerEnvironment *env, v3f pos,
			const std::string &data)
	{
		return new TestSAO(env, pos);
	}

	void step(float dtime, bool send_recommended)
	{
		m_age += dtime;
		if(m_age > 10)
		{
			m_pending_removal = true;
			return;
		}

		m_base_position.Y += dtime * BS * 2;
		if(m_base_position.Y > 8*BS)
			m_base_position.Y = 2*BS;

		if(send_recommended == false)
			return;

		m_timer1 -= dtime;
		if(m_timer1 < 0.0)
		{
			m_timer1 += 0.125;

			std::string data;

			data += itos(0); // 0 = position
			data += " ";
			data += itos(m_base_position.X);
			data += " ";
			data += itos(m_base_position.Y);
			data += " ";
			data += itos(m_base_position.Z);

			ActiveObjectMessage aom(getId(), false, data);
			m_messages_out.push(aom);
		}
	}

	bool getCollisionBox(aabb3f *toset) const { return false; }
	bool collideWithObjects() const { return false; }

private:
	float m_timer1;
	float m_age;
};

// Prototype (registers item for deserialization)
TestSAO proto_TestSAO(NULL, v3f(0,0,0));

/*
	UnitSAO
 */

UnitSAO::UnitSAO(ServerEnvironment *env, v3f pos):
	ServerActiveObject(env, pos),
	m_hp(-1),
	m_yaw(0),
	m_properties_sent(true),
	m_armor_groups_sent(false),
	m_animation_range(0,0),
	m_animation_speed(0),
	m_animation_blend(0),
	m_animation_loop(true),
	m_animation_sent(false),
	m_bone_position_sent(false),
	m_attachment_parent_id(0),
	m_attachment_sent(false)
{
	// Initialize something to armor groups
	m_armor_groups["fleshy"] = 100;
}

bool UnitSAO::isAttached() const
{
	if (!m_attachment_parent_id)
		return false;
	// Check if the parent still exists
	ServerActiveObject *obj = m_env->getActiveObject(m_attachment_parent_id);
	if (obj)
		return true;
	return false;
}

void UnitSAO::setArmorGroups(const ItemGroupList &armor_groups)
{
	m_armor_groups = armor_groups;
	m_armor_groups_sent = false;
}

const ItemGroupList &UnitSAO::getArmorGroups()
{
	return m_armor_groups;
}

void UnitSAO::setAnimation(v2f frame_range, float frame_speed, float frame_blend, bool frame_loop)
{
	// store these so they can be updated to clients
	m_animation_range = frame_range;
	m_animation_speed = frame_speed;
	m_animation_blend = frame_blend;
	m_animation_loop = frame_loop;
	m_animation_sent = false;
}

void UnitSAO::getAnimation(v2f *frame_range, float *frame_speed, float *frame_blend, bool *frame_loop)
{
	*frame_range = m_animation_range;
	*frame_speed = m_animation_speed;
	*frame_blend = m_animation_blend;
	*frame_loop = m_animation_loop;
}

void UnitSAO::setBonePosition(const std::string &bone, v3f position, v3f rotation)
{
	// store these so they can be updated to clients
	m_bone_position[bone] = core::vector2d<v3f>(position, rotation);
	m_bone_position_sent = false;
}

void UnitSAO::getBonePosition(const std::string &bone, v3f *position, v3f *rotation)
{
	*position = m_bone_position[bone].X;
	*rotation = m_bone_position[bone].Y;
}

void UnitSAO::setAttachment(int parent_id, const std::string &bone, v3f position, v3f rotation)
{
	// Attachments need to be handled on both the server and client.
	// If we just attach on the server, we can only copy the position of the parent. Attachments
	// are still sent to clients at an interval so players might see them lagging, plus we can't
	// read and attach to skeletal bones.
	// If we just attach on the client, the server still sees the child at its original location.
	// This breaks some things so we also give the server the most accurate representation
	// even if players only see the client changes.

	m_attachment_parent_id = parent_id;
	m_attachment_bone = bone;
	m_attachment_position = position;
	m_attachment_rotation = rotation;
	m_attachment_sent = false;
}

void UnitSAO::getAttachment(int *parent_id, std::string *bone, v3f *position,
	v3f *rotation)
{
	*parent_id = m_attachment_parent_id;
	*bone = m_attachment_bone;
	*position = m_attachment_position;
	*rotation = m_attachment_rotation;
}

void UnitSAO::addAttachmentChild(int child_id)
{
	m_attachment_child_ids.insert(child_id);
}

void UnitSAO::removeAttachmentChild(int child_id)
{
	m_attachment_child_ids.erase(child_id);
}

const UNORDERED_SET<int> &UnitSAO::getAttachmentChildIds()
{
	return m_attachment_child_ids;
}

ObjectProperties* UnitSAO::accessObjectProperties()
{
	return &m_prop;
}

void UnitSAO::notifyObjectPropertiesModified()
{
	m_properties_sent = false;
}

/*
	LuaEntitySAO
*/

// Prototype (registers item for deserialization)
LuaEntitySAO proto_LuaEntitySAO(NULL, v3f(0,0,0), "_prototype", "");

LuaEntitySAO::LuaEntitySAO(ServerEnvironment *env, v3f pos,
		const std::string &name, const std::string &state):
	UnitSAO(env, pos),
	m_init_name(name),
	m_init_state(state),
	m_registered(false),
	m_velocity(0,0,0),
	m_acceleration(0,0,0),
	m_last_sent_yaw(0),
	m_last_sent_position(0,0,0),
	m_last_sent_velocity(0,0,0),
	m_last_sent_position_timer(0),
	m_last_sent_move_precision(0),
	m_current_texture_modifier("")
{
	// Only register type if no environment supplied
	if(env == NULL){
		ServerActiveObject::registerType(getType(), create);
		return;
	}
}

LuaEntitySAO::~LuaEntitySAO()
{
	if(m_registered){
		m_env->getScriptIface()->luaentity_Remove(m_id);
	}

	for (UNORDERED_SET<u32>::iterator it = m_attached_particle_spawners.begin();
		it != m_attached_particle_spawners.end(); ++it) {
		m_env->deleteParticleSpawner(*it, false);
	}
}

void LuaEntitySAO::addedToEnvironment(u32 dtime_s)
{
	ServerActiveObject::addedToEnvironment(dtime_s);

	// Create entity from name
	m_registered = m_env->getScriptIface()->
		luaentity_Add(m_id, m_init_name.c_str());

	if(m_registered){
		// Get properties
		m_env->getScriptIface()->
			luaentity_GetProperties(m_id, &m_prop);
		// Initialize HP from properties
		m_hp = m_prop.hp_max;
		// Activate entity, supplying serialized state
		m_env->getScriptIface()->
			luaentity_Activate(m_id, m_init_state.c_str(), dtime_s);
	} else {
		m_prop.infotext = m_init_name;
	}
}

ServerActiveObject* LuaEntitySAO::create(ServerEnvironment *env, v3f pos,
		const std::string &data)
{
	std::string name;
	std::string state;
	s16 hp = 1;
	v3f velocity;
	float yaw = 0;
	if(data != ""){
		std::istringstream is(data, std::ios::binary);
		// read version
		u8 version = readU8(is);
		// check if version is supported
		if(version == 0){
			name = deSerializeString(is);
			state = deSerializeLongString(is);
		}
		else if(version == 1){
			name = deSerializeString(is);
			state = deSerializeLongString(is);
			hp = readS16(is);
			velocity = readV3F1000(is);
			yaw = readF1000(is);
		}
	}
	// create object
	infostream<<"LuaEntitySAO::create(name=\""<<name<<"\" state=\""
			<<state<<"\")"<<std::endl;
	LuaEntitySAO *sao = new LuaEntitySAO(env, pos, name, state);
	sao->m_hp = hp;
	sao->m_velocity = velocity;
	sao->m_yaw = yaw;
	return sao;
}

void LuaEntitySAO::step(float dtime, bool send_recommended)
{
	if(!m_properties_sent)
	{
		m_properties_sent = true;
		std::string str = getPropertyPacket();
		// create message and add to list
		ActiveObjectMessage aom(getId(), true, str);
		m_messages_out.push(aom);
	}

	// If attached, check that our parent is still there. If it isn't, detach.
	if(m_attachment_parent_id && !isAttached())
	{
		m_attachment_parent_id = 0;
		m_attachment_bone = "";
		m_attachment_position = v3f(0,0,0);
		m_attachment_rotation = v3f(0,0,0);
		sendPosition(false, true);
	}

	m_last_sent_position_timer += dtime;

	// Each frame, parent position is copied if the object is attached, otherwise it's calculated normally
	// If the object gets detached this comes into effect automatically from the last known origin
	if(isAttached())
	{
		v3f pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
		m_base_position = pos;
		m_velocity = v3f(0,0,0);
		m_acceleration = v3f(0,0,0);
	}
	else
	{
		if(m_prop.physical){
			aabb3f box = m_prop.collisionbox;
			box.MinEdge *= BS;
			box.MaxEdge *= BS;
			collisionMoveResult moveresult;
			f32 pos_max_d = BS*0.25; // Distance per iteration
			v3f p_pos = m_base_position;
			v3f p_velocity = m_velocity;
			v3f p_acceleration = m_acceleration;
			moveresult = collisionMoveSimple(m_env, m_env->getGameDef(),
					pos_max_d, box, m_prop.stepheight, dtime,
					&p_pos, &p_velocity, p_acceleration,
					this, m_prop.collideWithObjects);

			// Apply results
			m_base_position = p_pos;
			m_velocity = p_velocity;
			m_acceleration = p_acceleration;
		} else {
			m_base_position += dtime * m_velocity + 0.5 * dtime
					* dtime * m_acceleration;
			m_velocity += dtime * m_acceleration;
		}

		if((m_prop.automatic_face_movement_dir) &&
				(fabs(m_velocity.Z) > 0.001 || fabs(m_velocity.X) > 0.001))
		{
			float optimal_yaw = atan2(m_velocity.Z,m_velocity.X) * 180 / M_PI
					+ m_prop.automatic_face_movement_dir_offset;
			float max_rotation_delta =
					dtime * m_prop.automatic_face_movement_max_rotation_per_sec;

			if ((m_prop.automatic_face_movement_max_rotation_per_sec > 0) &&
				(fabs(m_yaw - optimal_yaw) > max_rotation_delta)) {

				m_yaw = optimal_yaw < m_yaw ? m_yaw - max_rotation_delta : m_yaw + max_rotation_delta;
			} else {
				m_yaw = optimal_yaw;
			}
		}
	}

	if(m_registered){
		m_env->getScriptIface()->luaentity_Step(m_id, dtime);
	}

	// Remove LuaEntity beyond terrain edges
	{
		ServerMap *map = dynamic_cast<ServerMap *>(&m_env->getMap());
		assert(map);
		if (!m_pending_deactivation &&
				map->saoPositionOverLimit(m_base_position)) {
			infostream << "Remove SAO " << m_id << "(" << m_init_name
				<< "), outside of limits" << std::endl;
			m_pending_deactivation = true;
			m_pending_removal = true;
			return;
		}
	}

	if(send_recommended == false)
		return;

	if(!isAttached())
	{
		// TODO: force send when acceleration changes enough?
		float minchange = 0.2*BS;
		if(m_last_sent_position_timer > 1.0){
			minchange = 0.01*BS;
		} else if(m_last_sent_position_timer > 0.2){
			minchange = 0.05*BS;
		}
		float move_d = m_base_position.getDistanceFrom(m_last_sent_position);
		move_d += m_last_sent_move_precision;
		float vel_d = m_velocity.getDistanceFrom(m_last_sent_velocity);
		if(move_d > minchange || vel_d > minchange ||
				fabs(m_yaw - m_last_sent_yaw) > 1.0){
			sendPosition(true, false);
		}
	}

	if(m_armor_groups_sent == false){
		m_armor_groups_sent = true;
		std::string str = gob_cmd_update_armor_groups(
				m_armor_groups);
		// create message and add to list
		ActiveObjectMessage aom(getId(), true, str);
		m_messages_out.push(aom);
	}

	if(m_animation_sent == false){
		m_animation_sent = true;
		std::string str = gob_cmd_update_animation(
			m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop);
		// create message and add to list
		ActiveObjectMessage aom(getId(), true, str);
		m_messages_out.push(aom);
	}

	if(m_bone_position_sent == false){
		m_bone_position_sent = true;
		for (UNORDERED_MAP<std::string, core::vector2d<v3f> >::const_iterator
				ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii){
			std::string str = gob_cmd_update_bone_position((*ii).first,
					(*ii).second.X, (*ii).second.Y);
			// create message and add to list
			ActiveObjectMessage aom(getId(), true, str);
			m_messages_out.push(aom);
		}
	}

	if(m_attachment_sent == false){
		m_attachment_sent = true;
		std::string str = gob_cmd_update_attachment(m_attachment_parent_id, m_attachment_bone, m_attachment_position, m_attachment_rotation);
		// create message and add to list
		ActiveObjectMessage aom(getId(), true, str);
		m_messages_out.push(aom);
	}
}

std::string LuaEntitySAO::getClientInitializationData(u16 protocol_version)
{
	std::ostringstream os(std::ios::binary);

	// protocol >= 14
	writeU8(os, 1); // version
	os << serializeString(""); // name
	writeU8(os, 0); // is_player
	writeS16(os, getId()); //id
	writeV3F1000(os, m_base_position);
	writeF1000(os, m_yaw);
	writeS16(os, m_hp);

	std::ostringstream msg_os(std::ios::binary);
	msg_os << serializeLongString(getPropertyPacket()); // message 1
	msg_os << serializeLongString(gob_cmd_update_armor_groups(m_armor_groups)); // 2
	msg_os << serializeLongString(gob_cmd_update_animation(
		m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop)); // 3
	for (UNORDERED_MAP<std::string, core::vector2d<v3f> >::const_iterator
			ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii) {
		msg_os << serializeLongString(gob_cmd_update_bone_position((*ii).first,
				(*ii).second.X, (*ii).second.Y)); // m_bone_position.size
	}
	msg_os << serializeLongString(gob_cmd_update_attachment(m_attachment_parent_id,
		m_attachment_bone, m_attachment_position, m_attachment_rotation)); // 4
	int message_count = 4 + m_bone_position.size();
	for (UNORDERED_SET<int>::const_iterator ii = m_attachment_child_ids.begin();
			(ii != m_attachment_child_ids.end()); ++ii) {
		if (ServerActiveObject *obj = m_env->getActiveObject(*ii)) {
			message_count++;
			msg_os << serializeLongString(gob_cmd_update_infant(*ii, obj->getSendType(),
				obj->getClientInitializationData(protocol_version)));
		}
	}

	msg_os << serializeLongString(gob_cmd_set_texture_mod(m_current_texture_modifier));
	message_count++;

	writeU8(os, message_count);
	os.write(msg_os.str().c_str(), msg_os.str().size());

	// return result
	return os.str();
}

void LuaEntitySAO::getStaticData(std::string *result) const
{
	verbosestream<<FUNCTION_NAME<<std::endl;
	std::ostringstream os(std::ios::binary);
	// version
	writeU8(os, 1);
	// name
	os<<serializeString(m_init_name);
	// state
	if(m_registered){
		std::string state = m_env->getScriptIface()->
			luaentity_GetStaticdata(m_id);
		os<<serializeLongString(state);
	} else {
		os<<serializeLongString(m_init_state);
	}
	// hp
	writeS16(os, m_hp);
	// velocity
	writeV3F1000(os, m_velocity);
	// yaw
	writeF1000(os, m_yaw);
	*result = os.str();
}

int LuaEntitySAO::punch(v3f dir,
		const ToolCapabilities *toolcap,
		ServerActiveObject *puncher,
		float time_from_last_punch)
{
	if (!m_registered) {
		// Delete unknown LuaEntities when punched
		m_pending_removal = true;
		return 0;
	}

	// It's best that attachments cannot be punched
	if (isAttached())
		return 0;

	ItemStack *punchitem = NULL;
	ItemStack punchitem_static;
	if (puncher) {
		punchitem_static = puncher->getWieldedItem();
		punchitem = &punchitem_static;
	}

	PunchDamageResult result = getPunchDamage(
			m_armor_groups,
			toolcap,
			punchitem,
			time_from_last_punch);

	bool damage_handled = m_env->getScriptIface()->luaentity_Punch(m_id, puncher,
			time_from_last_punch, toolcap, dir, result.did_punch ? result.damage : 0);

	if (!damage_handled) {
		if (result.did_punch) {
			setHP(getHP() - result.damage);

			if (result.damage > 0) {
				std::string punchername = puncher ? puncher->getDescription() : "nil";

				actionstream << getDescription() << " punched by "
						<< punchername << ", damage " << result.damage
						<< " hp, health now " << getHP() << " hp" << std::endl;
			}

			std::string str = gob_cmd_punched(result.damage, getHP());
			// create message and add to list
			ActiveObjectMessage aom(getId(), true, str);
			m_messages_out.push(aom);
		}
	}

	if (getHP() == 0)
		m_pending_removal = true;

	return result.wear;
}

void LuaEntitySAO::rightClick(ServerActiveObject *clicker)
{
	if (!m_registered)
		return;
	// It's best that attachments cannot be clicked
	if (isAttached())
		return;
	m_env->getScriptIface()->luaentity_Rightclick(m_id, clicker);
}

void LuaEntitySAO::setPos(const v3f &pos)
{
	if(isAttached())
		return;
	m_base_position = pos;
	sendPosition(false, true);
}

void LuaEntitySAO::moveTo(v3f pos, bool continuous)
{
	if(isAttached())
		return;
	m_base_position = pos;
	if(!continuous)
		sendPosition(true, true);
}

float LuaEntitySAO::getMinimumSavedMovement()
{
	return 0.1 * BS;
}

std::string LuaEntitySAO::getDescription()
{
	std::ostringstream os(std::ios::binary);
	os<<"LuaEntitySAO at (";
	os<<(m_base_position.X/BS)<<",";
	os<<(m_base_position.Y/BS)<<",";
	os<<(m_base_position.Z/BS);
	os<<")";
	return os.str();
}

void LuaEntitySAO::setHP(s16 hp)
{
	if(hp < 0) hp = 0;
	m_hp = hp;
}

s16 LuaEntitySAO::getHP() const
{
	return m_hp;
}

void LuaEntitySAO::setVelocity(v3f velocity)
{
	m_velocity = velocity;
}

v3f LuaEntitySAO::getVelocity()
{
	return m_velocity;
}

void LuaEntitySAO::setAcceleration(v3f acceleration)
{
	m_acceleration = acceleration;
}

v3f LuaEntitySAO::getAcceleration()
{
	return m_acceleration;
}

void LuaEntitySAO::setTextureMod(const std::string &mod)
{
	std::string str = gob_cmd_set_texture_mod(mod);
	m_current_texture_modifier = mod;
	// create message and add to list
	ActiveObjectMessage aom(getId(), true, str);
	m_messages_out.push(aom);
}

std::string LuaEntitySAO::getTextureMod() const
{
	return m_current_texture_modifier;
}

void LuaEntitySAO::setSprite(v2s16 p, int num_frames, float framelength,
		bool select_horiz_by_yawpitch)
{
	std::string str = gob_cmd_set_sprite(
		p,
		num_frames,
		framelength,
		select_horiz_by_yawpitch
	);
	// create message and add to list
	ActiveObjectMessage aom(getId(), true, str);
	m_messages_out.push(aom);
}

std::string LuaEntitySAO::getName()
{
	return m_init_name;
}

std::string LuaEntitySAO::getPropertyPacket()
{
	return gob_cmd_set_properties(m_prop);
}

void LuaEntitySAO::sendPosition(bool do_interpolate, bool is_movement_end)
{
	// If the object is attached client-side, don't waste bandwidth sending its position to clients
	if(isAttached())
		return;

	m_last_sent_move_precision = m_base_position.getDistanceFrom(
			m_last_sent_position);
	m_last_sent_position_timer = 0;
	m_last_sent_yaw = m_yaw;
	m_last_sent_position = m_base_position;
	m_last_sent_velocity = m_velocity;
	//m_last_sent_acceleration = m_acceleration;

	float update_interval = m_env->getSendRecommendedInterval();

	std::string str = gob_cmd_update_position(
		m_base_position,
		m_velocity,
		m_acceleration,
		m_yaw,
		do_interpolate,
		is_movement_end,
		update_interval
	);
	// create message and add to list
	ActiveObjectMessage aom(getId(), false, str);
	m_messages_out.push(aom);
}

bool LuaEntitySAO::getCollisionBox(aabb3f *toset) const
{
	if (m_prop.physical)
	{
		//update collision box
		toset->MinEdge = m_prop.collisionbox.MinEdge * BS;
		toset->MaxEdge = m_prop.collisionbox.MaxEdge * BS;

		toset->MinEdge += m_base_position;
		toset->MaxEdge += m_base_position;

		return true;
	}

	return false;
}

bool LuaEntitySAO::collideWithObjects() const
{
	return m_prop.collideWithObjects;
}

/*
	PlayerSAO
*/

// No prototype, PlayerSAO does not need to be deserialized

PlayerSAO::PlayerSAO(ServerEnvironment *env_, RemotePlayer *player_, u16 peer_id_,
		bool is_singleplayer):
	UnitSAO(env_, v3f(0,0,0)),
	m_player(player_),
	m_peer_id(peer_id_),
	m_inventory(NULL),
	m_damage(0),
	m_last_good_position(0,0,0),
	m_time_from_last_teleport(0),
	m_time_from_last_punch(0),
	m_nocheat_dig_pos(32767, 32767, 32767),
	m_nocheat_dig_time(0),
	m_wield_index(0),
	m_position_not_sent(false),
	m_is_singleplayer(is_singleplayer),
	m_breath(PLAYER_MAX_BREATH),
	m_pitch(0),
	m_fov(0),
	m_wanted_range(0),
	m_extended_attributes_modified(false),
	// public
	m_physics_override_speed(1),
	m_physics_override_jump(1),
	m_physics_override_gravity(1),
	m_physics_override_sneak(true),
	m_physics_override_sneak_glitch(false),
	m_physics_override_new_move(true),
	m_physics_override_sent(false)
{
	assert(m_peer_id != 0);	// pre-condition

	m_prop.hp_max = PLAYER_MAX_HP;
	m_prop.physical = false;
	m_prop.weight = 75;
	m_prop.collisionbox = aabb3f(-0.3f, -1.0f, -0.3f, 0.3f, 0.75f, 0.3f);
	// start of default appearance, this should be overwritten by LUA
	m_prop.visual = "upright_sprite";
	m_prop.visual_size = v2f(1, 2);
	m_prop.textures.clear();
	m_prop.textures.push_back("player.png");
	m_prop.textures.push_back("player_back.png");
	m_prop.colors.clear();
	m_prop.colors.push_back(video::SColor(255, 255, 255, 255));
	m_prop.spritediv = v2s16(1,1);
	// end of default appearance
	m_prop.is_visible = true;
	m_prop.makes_footstep_sound = true;
	m_hp = PLAYER_MAX_HP;
}

PlayerSAO::~PlayerSAO()
{
	if(m_inventory != &m_player->inventory)
		delete m_inventory;
}

void PlayerSAO::finalize(RemotePlayer *player, const std::set<std::string> &privs)
{
	assert(player);
	m_player = player;
	m_privs = privs;
	m_inventory = &m_player->inventory;
}

v3f PlayerSAO::getEyeOffset() const
{
	return v3f(0, BS * 1.625f, 0);
}

std::string PlayerSAO::getDescription()
{
	return std::string("player ") + m_player->getName();
}

// Called after id has been set and has been inserted in environment
void PlayerSAO::addedToEnvironment(u32 dtime_s)
{
	ServerActiveObject::addedToEnvironment(dtime_s);
	ServerActiveObject::setBasePosition(m_base_position);
	m_player->setPlayerSAO(this);
	m_player->peer_id = m_peer_id;
	m_last_good_position = m_base_position;
}

// Called before removing from environment
void PlayerSAO::removingFromEnvironment()
{
	ServerActiveObject::removingFromEnvironment();
	if (m_player->getPlayerSAO() == this) {
		unlinkPlayerSessionAndSave();
		for (UNORDERED_SET<u32>::iterator it = m_attached_particle_spawners.begin();
			it != m_attached_particle_spawners.end(); ++it) {
			m_env->deleteParticleSpawner(*it, false);
		}
	}
}

std::string PlayerSAO::getClientInitializationData(u16 protocol_version)
{
	std::ostringstream os(std::ios::binary);

	// Protocol >= 15
	writeU8(os, 1); // version
	os << serializeString(m_player->getName()); // name
	writeU8(os, 1); // is_player
	writeS16(os, getId()); //id
	writeV3F1000(os, m_base_position + v3f(0,BS*1,0));
	writeF1000(os, m_yaw);
	writeS16(os, getHP());

	std::ostringstream msg_os(std::ios::binary);
	msg_os << serializeLongString(getPropertyPacket()); // message 1
	msg_os << serializeLongString(gob_cmd_update_armor_groups(m_armor_groups)); // 2
	msg_os << serializeLongString(gob_cmd_update_animation(
		m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop)); // 3
	for (UNORDERED_MAP<std::string, core::vector2d<v3f> >::const_iterator
			ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii) {
		msg_os << serializeLongString(gob_cmd_update_bone_position((*ii).first,
			(*ii).second.X, (*ii).second.Y)); // m_bone_position.size
	}
	msg_os << serializeLongString(gob_cmd_update_attachment(m_attachment_parent_id,
		m_attachment_bone, m_attachment_position, m_attachment_rotation)); // 4
	msg_os << serializeLongString(gob_cmd_update_physics_override(m_physics_override_speed,
			m_physics_override_jump, m_physics_override_gravity, m_physics_override_sneak,
			m_physics_override_sneak_glitch, m_physics_override_new_move)); // 5
	// (GENERIC_CMD_UPDATE_NAMETAG_ATTRIBUTES) : Deprecated, for backwards compatibility only.
	msg_os << serializeLongString(gob_cmd_update_nametag_attributes(m_prop.nametag_color)); // 6
	int message_count = 6 + m_bone_position.size();
	for (UNORDERED_SET<int>::const_iterator ii = m_attachment_child_ids.begin();
			ii != m_attachment_child_ids.end(); ++ii) {
		if (ServerActiveObject *obj = m_env->getActiveObject(*ii)) {
			message_count++;
			msg_os << serializeLongString(gob_cmd_update_infant(*ii, obj->getSendType(),
				obj->getClientInitializationData(protocol_version)));
		}
	}

	writeU8(os, message_count);
	os.write(msg_os.str().c_str(), msg_os.str().size());

	// return result
	return os.str();
}

void PlayerSAO::getStaticData(std::string *result) const
{
	FATAL_ERROR("Deprecated function");
}

void PlayerSAO::step(float dtime, bool send_recommended)
{
	if (m_drowning_interval.step(dtime, 2.0)) {
		// get head position
		v3s16 p = floatToInt(m_base_position + v3f(0, BS * 1.6, 0), BS);
		MapNode n = m_env->getMap().getNodeNoEx(p);
		const ContentFeatures &c = m_env->getGameDef()->ndef()->get(n);
		// If node generates drown
		if (c.drowning > 0 && m_hp > 0) {
			if (m_breath > 0)
				setBreath(m_breath - 1);

			// No more breath, damage player
			if (m_breath == 0) {
				setHP(m_hp - c.drowning);
				m_env->getGameDef()->SendPlayerHPOrDie(this);
			}
		}
	}

	if (m_breathing_interval.step(dtime, 0.5)) {
		// get head position
		v3s16 p = floatToInt(m_base_position + v3f(0, BS * 1.6, 0), BS);
		MapNode n = m_env->getMap().getNodeNoEx(p);
		const ContentFeatures &c = m_env->getGameDef()->ndef()->get(n);
		// If player is alive & no drowning, breath
		if (m_hp > 0 && m_breath < PLAYER_MAX_BREATH && c.drowning == 0)
			setBreath(m_breath + 1);
	}

	if (m_node_hurt_interval.step(dtime, 1.0)) {
		// Feet, middle and head
		v3s16 p1 = floatToInt(m_base_position + v3f(0, BS*0.1, 0), BS);
		MapNode n1 = m_env->getMap().getNodeNoEx(p1);
		v3s16 p2 = floatToInt(m_base_position + v3f(0, BS*0.8, 0), BS);
		MapNode n2 = m_env->getMap().getNodeNoEx(p2);
		v3s16 p3 = floatToInt(m_base_position + v3f(0, BS*1.6, 0), BS);
		MapNode n3 = m_env->getMap().getNodeNoEx(p3);

		u32 damage_per_second = 0;
		damage_per_second = MYMAX(damage_per_second,
			m_env->getGameDef()->ndef()->get(n1).damage_per_second);
		damage_per_second = MYMAX(damage_per_second,
			m_env->getGameDef()->ndef()->get(n2).damage_per_second);
		damage_per_second = MYMAX(damage_per_second,
			m_env->getGameDef()->ndef()->get(n3).damage_per_second);

		if (damage_per_second != 0 && m_hp > 0) {
			s16 newhp = ((s32) damage_per_second > m_hp ? 0 : m_hp - damage_per_second);
			setHP(newhp);
			m_env->getGameDef()->SendPlayerHPOrDie(this);
		}
	}

	if (!m_properties_sent) {
		m_properties_sent = true;
		std::string str = getPropertyPacket();
		// create message and add to list
		ActiveObjectMessage aom(getId(), true, str);
		m_messages_out.push(aom);
	}

	// If attached, check that our parent is still there. If it isn't, detach.
	if(m_attachment_parent_id && !isAttached())
	{
		m_attachment_parent_id = 0;
		m_attachment_bone = "";
		m_attachment_position = v3f(0,0,0);
		m_attachment_rotation = v3f(0,0,0);
		setBasePosition(m_last_good_position);
		m_env->getGameDef()->SendMovePlayer(m_peer_id);
	}

	//dstream<<"PlayerSAO::step: dtime: "<<dtime<<std::endl;

	// Set lag pool maximums based on estimated lag
	const float LAG_POOL_MIN = 5.0;
	float lag_pool_max = m_env->getMaxLagEstimate() * 2.0;
	if(lag_pool_max < LAG_POOL_MIN)
		lag_pool_max = LAG_POOL_MIN;
	m_dig_pool.setMax(lag_pool_max);
	m_move_pool.setMax(lag_pool_max);

	// Increment cheat prevention timers
	m_dig_pool.add(dtime);
	m_move_pool.add(dtime);
	m_time_from_last_teleport += dtime;
	m_time_from_last_punch += dtime;
	m_nocheat_dig_time += dtime;

	// Each frame, parent position is copied if the object is attached, otherwise it's calculated normally
	// If the object gets detached this comes into effect automatically from the last known origin
	if (isAttached()) {
		v3f pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
		m_last_good_position = pos;
		setBasePosition(pos);
	}

	if (!send_recommended)
		return;

	// If the object is attached client-side, don't waste bandwidth sending its position to clients
	if(m_position_not_sent && !isAttached())
	{
		m_position_not_sent = false;
		float update_interval = m_env->getSendRecommendedInterval();
		v3f pos;
		if(isAttached()) // Just in case we ever do send attachment position too
			pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
		else
			pos = m_base_position + v3f(0,BS*1,0);
		std::string str = gob_cmd_update_position(
			pos,
			v3f(0,0,0),
			v3f(0,0,0),
			m_yaw,
			true,
			false,
			update_interval
		);
		// create message and add to list
		ActiveObjectMessage aom(getId(), false, str);
		m_messages_out.push(aom);
	}

	if (!m_armor_groups_sent) {
		m_armor_groups_sent = true;
		std::string str = gob_cmd_update_armor_groups(
				m_armor_groups);
		// create message and add to list
		ActiveObjectMessage aom(getId(), true, str);
		m_messages_out.push(aom);
	}

	if (!m_physics_override_sent) {
		m_physics_override_sent = true;
		std::string str = gob_cmd_update_physics_override(m_physics_override_speed,
				m_physics_override_jump, m_physics_override_gravity,
				m_physics_override_sneak, m_physics_override_sneak_glitch,
				m_physics_override_new_move);
		// create message and add to list
		ActiveObjectMessage aom(getId(), true, str);
		m_messages_out.push(aom);
	}

	if (!m_animation_sent) {
		m_animation_sent = true;
		std::string str = gob_cmd_update_animation(
			m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop);
		// create message and add to list
		ActiveObjectMessage aom(getId(), true, str);
		m_messages_out.push(aom);
	}

	if (!m_bone_position_sent) {
		m_bone_position_sent = true;
		for (UNORDERED_MAP<std::string, core::vector2d<v3f> >::const_iterator
				ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii) {
			std::string str = gob_cmd_update_bone_position((*ii).first,
					(*ii).second.X, (*ii).second.Y);
			// create message and add to list
			ActiveObjectMessage aom(getId(), true, str);
			m_messages_out.push(aom);
		}
	}

	if (!m_attachment_sent){
		m_attachment_sent = true;
		std::string str = gob_cmd_update_attachment(m_attachment_parent_id,
				m_attachment_bone, m_attachment_position, m_attachment_rotation);
		// create message and add to list
		ActiveObjectMessage aom(getId(), true, str);
		m_messages_out.push(aom);
	}
}

void PlayerSAO::setBasePosition(const v3f &position)
{
	if (m_player && position != m_base_position)
		m_player->setDirty(true);

	// This needs to be ran for attachments too
	ServerActiveObject::setBasePosition(position);
	m_position_not_sent = true;
}

void PlayerSAO::setPos(const v3f &pos)
{
	if(isAttached())
		return;

	setBasePosition(pos);
	// Movement caused by this command is always valid
	m_last_good_position = pos;
	m_move_pool.empty();
	m_time_from_last_teleport = 0.0;
	m_env->getGameDef()->SendMovePlayer(m_peer_id);
}

void PlayerSAO::moveTo(v3f pos, bool continuous)
{
	if(isAttached())
		return;

	setBasePosition(pos);
	// Movement caused by this command is always valid
	m_last_good_position = pos;
	m_move_pool.empty();
	m_time_from_last_teleport = 0.0;
	m_env->getGameDef()->SendMovePlayer(m_peer_id);
}

void PlayerSAO::setYaw(const float yaw)
{
	if (m_player && yaw != m_yaw)
		m_player->setDirty(true);

	UnitSAO::setYaw(yaw);
}

void PlayerSAO::setFov(const float fov)
{
	if (m_player && fov != m_fov)
		m_player->setDirty(true);

	m_fov = fov;
}

void PlayerSAO::setWantedRange(const s16 range)
{
	if (m_player && range != m_wanted_range)
		m_player->setDirty(true);

	m_wanted_range = range;
}

void PlayerSAO::setYawAndSend(const float yaw)
{
	setYaw(yaw);
	m_env->getGameDef()->SendMovePlayer(m_peer_id);
}

void PlayerSAO::setPitch(const float pitch)
{
	if (m_player && pitch != m_pitch)
		m_player->setDirty(true);

	m_pitch = pitch;
}

void PlayerSAO::setPitchAndSend(const float pitch)
{
	setPitch(pitch);
	m_env->getGameDef()->SendMovePlayer(m_peer_id);
}

int PlayerSAO::punch(v3f dir,
	const ToolCapabilities *toolcap,
	ServerActiveObject *puncher,
	float time_from_last_punch)
{
	// It's best that attachments cannot be punched
	if (isAttached())
		return 0;

	if (!toolcap)
		return 0;

	// No effect if PvP disabled
	if (g_settings->getBool("enable_pvp") == false) {
		if (puncher->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
			std::string str = gob_cmd_punched(0, getHP());
			// create message and add to list
			ActiveObjectMessage aom(getId(), true, str);
			m_messages_out.push(aom);
			return 0;
		}
	}

	HitParams hitparams = getHitParams(m_armor_groups, toolcap,
			time_from_last_punch);

	std::string punchername = "nil";

	if (puncher != 0)
		punchername = puncher->getDescription();

	PlayerSAO *playersao = m_player->getPlayerSAO();

	bool damage_handled = m_env->getScriptIface()->on_punchplayer(playersao,
				puncher, time_from_last_punch, toolcap, dir,
				hitparams.hp);

	if (!damage_handled) {
		setHP(getHP() - hitparams.hp);
	} else { // override client prediction
		if (puncher->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
			std::string str = gob_cmd_punched(0, getHP());
			// create message and add to list
			ActiveObjectMessage aom(getId(), true, str);
			m_messages_out.push(aom);
		}
	}

	actionstream << "Player " << m_player->getName() << " punched by "
			<< punchername;
	if (!damage_handled) {
		actionstream << ", damage " << hitparams.hp << " HP";
	} else {
		actionstream << ", damage handled by lua";
	}
	actionstream << std::endl;

	return hitparams.wear;
}

s16 PlayerSAO::readDamage()
{
	s16 damage = m_damage;
	m_damage = 0;
	return damage;
}

void PlayerSAO::setHP(s16 hp)
{
	s16 oldhp = m_hp;

	s16 hp_change = m_env->getScriptIface()->on_player_hpchange(this, hp - oldhp);
	if (hp_change == 0)
		return;
	hp = oldhp + hp_change;

	if (hp < 0)
		hp = 0;
	else if (hp > PLAYER_MAX_HP)
		hp = PLAYER_MAX_HP;

	if (hp < oldhp && !g_settings->getBool("enable_damage")) {
		return;
	}

	m_hp = hp;

	if (oldhp > hp)
		m_damage += (oldhp - hp);

	// Update properties on death
	if ((hp == 0) != (oldhp == 0))
		m_properties_sent = false;
}

void PlayerSAO::setBreath(const u16 breath, bool send)
{
	if (m_player && breath != m_breath)
		m_player->setDirty(true);

	m_breath = MYMIN(breath, PLAYER_MAX_BREATH);

	if (send)
		m_env->getGameDef()->SendPlayerBreath(this);
}

Inventory* PlayerSAO::getInventory()
{
	return m_inventory;
}
const Inventory* PlayerSAO::getInventory() const
{
	return m_inventory;
}

InventoryLocation PlayerSAO::getInventoryLocation() const
{
	InventoryLocation loc;
	loc.setPlayer(m_player->getName());
	return loc;
}

std::string PlayerSAO::getWieldList() const
{
	return "main";
}

ItemStack PlayerSAO::getWieldedItem() const
{
	const Inventory *inv = getInventory();
	ItemStack ret;
	const InventoryList *mlist = inv->getList(getWieldList());
	if (mlist && getWieldIndex() < (s32)mlist->getSize())
		ret = mlist->getItem(getWieldIndex());
	return ret;
}

ItemStack PlayerSAO::getWieldedItemOrHand() const
{
	const Inventory *inv = getInventory();
	ItemStack ret;
	const InventoryList *mlist = inv->getList(getWieldList());
	if (mlist && getWieldIndex() < (s32)mlist->getSize())
		ret = mlist->getItem(getWieldIndex());
	if (ret.name.empty()) {
		const InventoryList *hlist = inv->getList("hand");
		if (hlist)
			ret = hlist->getItem(0);
	}
	return ret;
}

bool PlayerSAO::setWieldedItem(const ItemStack &item)
{
	Inventory *inv = getInventory();
	if (inv) {
		InventoryList *mlist = inv->getList(getWieldList());
		if (mlist) {
			mlist->changeItem(getWieldIndex(), item);
			return true;
		}
	}
	return false;
}

int PlayerSAO::getWieldIndex() const
{
	return m_wield_index;
}

void PlayerSAO::setWieldIndex(int i)
{
	if(i != m_wield_index) {
		m_wield_index = i;
	}
}

void PlayerSAO::disconnected()
{
	m_peer_id = 0;
	m_pending_removal = true;
}

void PlayerSAO::unlinkPlayerSessionAndSave()
{
	assert(m_player->getPlayerSAO() == this);
	m_player->peer_id = 0;
	m_env->savePlayer(m_player);
	m_player->setPlayerSAO(NULL);
	m_env->removePlayer(m_player);
}

std::string PlayerSAO::getPropertyPacket()
{
	m_prop.is_visible = (true);
	return gob_cmd_set_properties(m_prop);
}

bool PlayerSAO::checkMovementCheat()
{
	if (isAttached() || m_is_singleplayer ||
			g_settings->getBool("disable_anticheat")) {
		m_last_good_position = m_base_position;
		return false;
	}

	bool cheated = false;
	/*
		Check player movements

		NOTE: Actually the server should handle player physics like the
		client does and compare player's position to what is calculated
		on our side. This is required when eg. players fly due to an
		explosion. Altough a node-based alternative might be possible
		too, and much more lightweight.
	*/

	float player_max_speed = 0;

	if (m_privs.count("fast") != 0) {
		// Fast speed
		player_max_speed = m_player->movement_speed_fast * m_physics_override_speed;
	} else {
		// Normal speed
		player_max_speed = m_player->movement_speed_walk * m_physics_override_speed;
	}
	// Tolerance. The lag pool does this a bit.
	//player_max_speed *= 2.5;

	v3f diff = (m_base_position - m_last_good_position);
	float d_vert = diff.Y;
	diff.Y = 0;
	float d_horiz = diff.getLength();
	float required_time = d_horiz / player_max_speed;

	if (d_vert > 0 && d_vert / player_max_speed > required_time)
		required_time = d_vert / player_max_speed; // Moving upwards

	if (m_move_pool.grab(required_time)) {
		m_last_good_position = m_base_position;
	} else {
		const float LAG_POOL_MIN = 5.0;
		float lag_pool_max = m_env->getMaxLagEstimate() * 2.0;
		lag_pool_max = MYMAX(lag_pool_max, LAG_POOL_MIN);
		if (m_time_from_last_teleport > lag_pool_max) {
			actionstream << "Player " << m_player->getName()
					<< " moved too fast; resetting position"
					<< std::endl;
			cheated = true;
		}
		setBasePosition(m_last_good_position);
	}
	return cheated;
}

bool PlayerSAO::getCollisionBox(aabb3f *toset) const
{
	*toset = aabb3f(-0.3f * BS, 0.0f, -0.3f * BS, 0.3f * BS, 1.75f * BS, 0.3f * BS);

	toset->MinEdge += m_base_position;
	toset->MaxEdge += m_base_position;
	return true;
}