data/mud.png

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

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

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

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

#include "content_mapblock.h"
#include "util/numeric.h"
#include "util/directiontables.h"
#include "mapblock_mesh.h" // For MapBlock_LightColor() and MeshCollector
#include "settings.h"
#include "nodedef.h"
#include "client/tile.h"
#include "mesh.h"
#include <IMeshManipulator.h>
#include "gamedef.h"
#include "log.h"
#include "noise.h"


// Create a cuboid.
//  collector - the MeshCollector for the resulting polygons
//  box       - the position and size of the box
//  tiles     - the tiles (materials) to use (for all 6 faces)
//  tilecount - number of entries in tiles, 1<=tilecount<=6
//  c         - vertex colour - used for all
//  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. Alternatively, pass
//              NULL to use the entire texture for each face. The order of
//              the faces in the list is up-down-right-left-back-front
//              (compatible with ContentFeatures). If you specified 0,0,1,1
//              for each face, that would be the same as passing NULL.
void makeCuboid(MeshCollector *collector, const aabb3f &box,
	TileSpec *tiles, int tilecount, video::SColor &c, const f32* txc)
{
	assert(tilecount >= 1 && tilecount <= 6); // pre-condition

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


	if(txc == NULL) {
		static const f32 txc_default[24] = {
			0,0,1,1,
			0,0,1,1,
			0,0,1,1,
			0,0,1,1,
			0,0,1,1,
			0,0,1,1
		};
		txc = txc_default;
	}

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

	for(int i = 0; i < 6; i++)
				{
				switch (tiles[MYMIN(i, tilecount-1)].rotation)
				{
				case 0:
					break;
				case 1: //R90
					for (int x = 0; x < 4; x++)
						vertices[i*4+x].TCoords.rotateBy(90,irr::core::vector2df(0, 0));
					break;
				case 2: //R180
					for (int x = 0; x < 4; x++)
						vertices[i*4+x].TCoords.rotateBy(180,irr::core::vector2df(0, 0));
					break;
				case 3: //R270
					for (int x = 0; x < 4; x++)
						vertices[i*4+x].TCoords.rotateBy(270,irr::core::vector2df(0, 0));
					break;
				case 4: //FXR90
					for (int x = 0; x < 4; x++){
						vertices[i*4+x].TCoords.X = 1.0 - vertices[i*4+x].TCoords.X;
						vertices[i*4+x].TCoords.rotateBy(90,irr::core::vector2df(0, 0));
					}
					break;
				case 5: //FXR270
					for (int x = 0; x < 4; x++){
						vertices[i*4+x].TCoords.X = 1.0 - vertices[i*4+x].TCoords.X;
						vertices[i*4+x].TCoords.rotateBy(270,irr::core::vector2df(0, 0));
					}
					break;
				case 6: //FYR90
					for (int x = 0; x < 4; x++){
						vertices[i*4+x].TCoords.Y = 1.0 - vertices[i*4+x].TCoords.Y;
						vertices[i*4+x].TCoords.rotateBy(90,irr::core::vector2df(0, 0));
					}
					break;
				case 7: //FYR270
					for (int x = 0; x < 4; x++){
						vertices[i*4+x].TCoords.Y = 1.0 - vertices[i*4+x].TCoords.Y;
						vertices[i*4+x].TCoords.rotateBy(270,irr::core::vector2df(0, 0));
					}
					break;
				case 8: //FX
					for (int x = 0; x < 4; x++){
						vertices[i*4+x].TCoords.X = 1.0 - vertices[i*4+x].TCoords.X;
					}
					break;
				case 9: //FY
					for (int x = 0; x < 4; x++){
						vertices[i*4+x].TCoords.Y = 1.0 - vertices[i*4+x].TCoords.Y;
					}
					break;
				default:
					break;
				}
			}
	u16 indices[] = {0,1,2,2,3,0};
	// Add to mesh collector
	for (s32 j = 0; j < 24; j += 4) {
		int tileindex = MYMIN(j / 4, tilecount - 1);
		collector->append(tiles[tileindex], vertices + j, 4, indices, 6);
	}
}

static inline void getNeighborConnectingFace(v3s16 p, INodeDefManager *nodedef,
		MeshMakeData *data, MapNode n, int v, int *neighbors)
{
	MapNode n2 = data->m_vmanip.getNodeNoEx(p);
	if (nodedef->nodeboxConnects(n, n2, v))
		*neighbors |= v;
}

// For use in mapblock_mesh_generate_special
// X,Y,Z of position must be -1,0,1
// This expression is a simplification of
// 3 * 3 * (pos.X + 1) + 3 * (pos.Y + 1) + (pos.Z + 1)
static inline int NeighborToIndex(const v3s16 &pos)
{
	return 9 * pos.X + 3 * pos.Y + pos.Z + 13;
}

/*
	TODO: Fix alpha blending for special nodes
	Currently only the last element rendered is blended correct
*/
void mapblock_mesh_generate_special(MeshMakeData *data,
		MeshCollector &collector)
{
	INodeDefManager *nodedef = data->m_gamedef->ndef();
	scene::ISceneManager* smgr = data->m_gamedef->getSceneManager();
	scene::IMeshManipulator* meshmanip = smgr->getMeshManipulator();

	// 0ms
	//TimeTaker timer("mapblock_mesh_generate_special()");

	/*
		Some settings
	*/
	bool enable_mesh_cache	= g_settings->getBool("enable_mesh_cache");

	v3s16 blockpos_nodes = data->m_blockpos*MAP_BLOCKSIZE;

	for(s16 z = 0; z < MAP_BLOCKSIZE; z++)
	for(s16 y = 0; y < MAP_BLOCKSIZE; y++)
	for(s16 x = 0; x < MAP_BLOCKSIZE; x++)
	{
		v3s16 p(x,y,z);

		MapNode n = data->m_vmanip.getNodeNoEx(blockpos_nodes + p);
		const ContentFeatures &f = nodedef->get(n);

		// Only solidness=0 stuff is drawn here
		if(f.solidness != 0)
			continue;

		switch(f.drawtype){
		default:
			infostream << "Got " << f.drawtype << std::endl;
			FATAL_ERROR("Unknown drawtype");
			break;
		case NDT_AIRLIKE:
			break;
		case NDT_LIQUID:
		{
			/*
				Add water sources to mesh if using new style
			*/
			TileSpec tile_liquid = f.special_tiles[0];
			TileSpec tile_liquid_bfculled = getNodeTile(n, p, v3s16(0,0,0), data);

			bool top_is_same_liquid = false;
			MapNode ntop = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y+1,z));
			content_t c_flowing = nodedef->getId(f.liquid_alternative_flowing);
			content_t c_source = nodedef->getId(f.liquid_alternative_source);
			if(ntop.getContent() == c_flowing || ntop.getContent() == c_source)
				top_is_same_liquid = true;

			u16 l = getInteriorLight(n, 0, nodedef);
			video::SColor c = MapBlock_LightColor(f.alpha, l, f.light_source);

			/*
				Generate sides
			 */
			v3s16 side_dirs[4] = {
				v3s16(1,0,0),
				v3s16(-1,0,0),
				v3s16(0,0,1),
				v3s16(0,0,-1),
			};
			for(u32 i=0; i<4; i++)
			{
				v3s16 dir = side_dirs[i];

				MapNode neighbor = data->m_vmanip.getNodeNoEx(blockpos_nodes + p + dir);
				content_t neighbor_content = neighbor.getContent();
				const ContentFeatures &n_feat = nodedef->get(neighbor_content);
				MapNode n_top = data->m_vmanip.getNodeNoEx(blockpos_nodes + p + dir+ v3s16(0,1,0));
				content_t n_top_c = n_top.getContent();

				if(neighbor_content == CONTENT_IGNORE)
					continue;

				/*
					If our topside is liquid and neighbor's topside
					is liquid, don't draw side face
				*/
				if(top_is_same_liquid && (n_top_c == c_flowing ||
						n_top_c == c_source || n_top_c == CONTENT_IGNORE))
					continue;

				// Don't draw face if neighbor is blocking the view
				if(n_feat.solidness == 2)
					continue;

				bool neighbor_is_same_liquid = (neighbor_content == c_source
						|| neighbor_content == c_flowing);

				// Don't draw any faces if neighbor same is liquid and top is
				// same liquid
				if(neighbor_is_same_liquid && !top_is_same_liquid)
					continue;

				// Use backface culled material if neighbor doesn't have a
				// solidness of 0
				const TileSpec *current_tile = &tile_liquid;
				if(n_feat.solidness != 0 || n_feat.visual_solidness != 0)
					current_tile = &tile_liquid_bfculled;

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

				/*
					If our topside is liquid, set upper border of face
					at upper border of node
				*/
				if (top_is_same_liquid) {
					vertices[2].Pos.Y = 0.5 * BS;
					vertices[3].Pos.Y = 0.5 * BS;
				} else {
				/*
					Otherwise upper position of face is liquid level
				*/
					vertices[2].Pos.Y = 0.5 * BS;
					vertices[3].Pos.Y = 0.5 * BS;
				}
				/*
					If neighbor is liquid, lower border of face is liquid level
				*/
				if (neighbor_is_same_liquid) {
					vertices[0].Pos.Y = 0.5 * BS;
					vertices[1].Pos.Y = 0.5 * BS;
				} else {
				/*
					If neighbor is not liquid, lower border of face is
					lower border of node
				*/
					vertices[0].Pos.Y = -0.5 * BS;
					vertices[1].Pos.Y = -0.5 * BS;
				}

				for(s32 j=0; j<4; j++)
				{
					if(dir == v3s16(0,0,1))
						vertices[j].Pos.rotateXZBy(0);
					if(dir == v3s16(0,0,-1))
						vertices[j].Pos.rotateXZBy(180);
					if(dir == v3s16(-1,0,0))
						vertices[j].Pos.rotateXZBy(90);
					if(dir == v3s16(1,0,-0))
						vertices[j].Pos.rotateXZBy(-90);

					// Do this to not cause glitches when two liquids are
					// side-by-side
					/*if(neighbor_is_same_liquid == false){
						vertices[j].Pos.X *= 0.98;
						vertices[j].Pos.Z *= 0.98;
					}*/

					vertices[j].Pos += intToFloat(p, BS);
				}

				u16 indices[] = {0,1,2,2,3,0};
				// Add to mesh collector
				collector.append(*current_tile, vertices, 4, indices, 6);
			}

			/*
				Generate top
			 */
			if(top_is_same_liquid)
				continue;

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

			v3f offset(p.X * BS, (p.Y + 0.5) * BS, p.Z * BS);
			for(s32 i=0; i<4; i++)
			{
				vertices[i].Pos += offset;
			}

			u16 indices[] = {0,1,2,2,3,0};
			// Add to mesh collector
			collector.append(tile_liquid, vertices, 4, indices, 6);
		break;}
		case NDT_FLOWINGLIQUID:
		{
			/*
				Add flowing liquid to mesh
			*/
			TileSpec tile_liquid = f.special_tiles[0];
			TileSpec tile_liquid_bfculled = f.special_tiles[1];

			bool top_is_same_liquid = false;
			MapNode ntop = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y+1,z));
			content_t c_flowing = nodedef->getId(f.liquid_alternative_flowing);
			content_t c_source = nodedef->getId(f.liquid_alternative_source);
			if(ntop.getContent() == c_flowing || ntop.getContent() == c_source)
				top_is_same_liquid = true;

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

			u8 range = rangelim(nodedef->get(c_flowing).liquid_range, 1, 8);

			// Neighbor liquid levels (key = relative position)
			// Includes current node

			struct NeighborData {
				f32 level;
				content_t content;
				u8 flags;
			};
			NeighborData neighbor_data_matrix[27];

			const u8 neighborflag_top_is_same_liquid = 0x01;
			v3s16 neighbor_dirs[9] = {
				v3s16(0,0,0),
				v3s16(0,0,1),
				v3s16(0,0,-1),
				v3s16(1,0,0),
				v3s16(-1,0,0),
				v3s16(1,0,1),
				v3s16(-1,0,-1),
				v3s16(1,0,-1),
				v3s16(-1,0,1),
			};
			for(u32 i=0; i<9; i++)
			{
				content_t content = CONTENT_AIR;
				float level = -0.5 * BS;
				u8 flags = 0;
				// Check neighbor
				v3s16 p2 = p + neighbor_dirs[i];
				MapNode n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p2);
				if(n2.getContent() != CONTENT_IGNORE)
				{
					content = n2.getContent();

					if(n2.getContent() == c_source)
						level = 0.5 * BS;
					else if(n2.getContent() == c_flowing){
						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);
						level = (-0.5 + ((float)liquid_level + 0.5) / (float)range) * BS;
					}

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

				NeighborData &neighbor_data =
					neighbor_data_matrix[NeighborToIndex(neighbor_dirs[i])];

				neighbor_data.level = level;
				neighbor_data.content = content;
				neighbor_data.flags = flags;
			}

			// Corner heights (average between four liquids)
			f32 corner_levels[4];

			v3s16 halfdirs[4] = {
				v3s16(0,0,0),
				v3s16(1,0,0),
				v3s16(1,0,1),
				v3s16(0,0,1),
			};
			for(u32 i=0; i<4; i++)
			{
				v3s16 cornerdir = halfdirs[i];
				float cornerlevel = 0;
				u32 valid_count = 0;
				u32 air_count = 0;
				for(u32 j=0; j<4; j++)
				{
					v3s16 neighbordir = cornerdir - halfdirs[j];

					NeighborData &neighbor_data =
						neighbor_data_matrix[NeighborToIndex(neighbordir)];
					content_t content = neighbor_data.content;
					// If top is liquid, draw starting from top of node
					if (neighbor_data.flags & neighborflag_top_is_same_liquid)
					{
						cornerlevel = 0.5*BS;
						valid_count = 1;
						break;
					}
					// Source is always the same height
					else if(content == c_source)
					{
						cornerlevel = 0.5 * BS;
						valid_count = 1;
						break;
					}
					// Flowing liquid has level information
					else if(content == c_flowing)
					{
						cornerlevel += neighbor_data.level;
						valid_count++;
					}
					else if(content == CONTENT_AIR)
					{
						air_count++;
					}
				}
				if(air_count >= 2)
					cornerlevel = -0.5*BS+0.2;
				else if(valid_count > 0)
					cornerlevel /= valid_count;
				corner_levels[i] = cornerlevel;
			}

			/*
				Generate sides
			*/

			v3s16 side_dirs[4] = {
				v3s16(1,0,0),
				v3s16(-1,0,0),
				v3s16(0,0,1),
				v3s16(0,0,-1),
			};
			s16 side_corners[4][2] = {
				{1, 2},
				{3, 0},
				{2, 3},
				{0, 1},
			};
			for(u32 i=0; i<4; i++)
			{
				v3s16 dir = side_dirs[i];

				NeighborData& neighbor_data =
					neighbor_data_matrix[NeighborToIndex(dir)];
				/*
					If our topside is liquid and neighbor's topside
					is liquid, don't draw side face
				*/
				if (top_is_same_liquid &&
						neighbor_data.flags & neighborflag_top_is_same_liquid)
					continue;

				content_t neighbor_content = neighbor_data.content;
				const ContentFeatures &n_feat = nodedef->get(neighbor_content);

				// Don't draw face if neighbor is blocking the view
				if(n_feat.solidness == 2)
					continue;

				bool neighbor_is_same_liquid = (neighbor_content == c_source
						|| neighbor_content == c_flowing);

				// Don't draw any faces if neighbor same is liquid and top is
				// same liquid
				if(neighbor_is_same_liquid == true
						&& top_is_same_liquid == false)
					continue;

				// Use backface culled material if neighbor doesn't have a
				// solidness of 0
				const TileSpec *current_tile = &tile_liquid;
				if(n_feat.solidness != 0 || n_feat.visual_solidness != 0)
					current_tile = &tile_liquid_bfculled;

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

				/*
					If our topside is liquid, set upper border of face
					at upper border of node
				*/
				if(top_is_same_liquid)
				{
					vertices[2].Pos.Y = 0.5*BS;
					vertices[3].Pos.Y = 0.5*BS;
				}
				/*
					Otherwise upper position of face is corner levels
				*/
				else
				{
					vertices[2].Pos.Y = corner_levels[side_corners[i][0]];
					vertices[3].Pos.Y = corner_levels[side_corners[i][1]];
				}

				/*
					If neighbor is liquid, lower border of face is corner
					liquid levels
				*/
				if(neighbor_is_same_liquid)
				{
					vertices[0].Pos.Y = corner_levels[side_corners[i][1]];
					vertices[1].Pos.Y = corner_levels[side_corners[i][0]];
				}
				/*
					If neighbor is not liquid, lower border of face is
					lower border of node
				*/
				else
				{
					vertices[0].Pos.Y = -0.5*BS;
					vertices[1].Pos.Y = -0.5*BS;
				}

				for(s32 j=0; j<4; j++)
				{
					if(dir == v3s16(0,0,1))
						vertices[j].Pos.rotateXZBy(0);
					if(dir == v3s16(0,0,-1))
						vertices[j].Pos.rotateXZBy(180);
					if(dir == v3s16(-1,0,0))
						vertices[j].Pos.rotateXZBy(90);
					if(dir == v3s16(1,0,-0))
						vertices[j].Pos.rotateXZBy(-90);

					// Do this to not cause glitches when two liquids are
					// side-by-side
					/*if(neighbor_is_same_liquid == false){
						vertices[j].Pos.X *= 0.98;
						vertices[j].Pos.Z *= 0.98;
					}*/

					vertices[j].Pos += intToFloat(p, BS);
				}

				u16 indices[] = {0,1,2,2,3,0};
				// Add to mesh collector
				collector.append(*current_tile, vertices, 4, indices, 6);
			}

			/*
				Generate top side, if appropriate
			*/

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

				// 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.
				s32 corner_resolve[4] = {3,2,1,0};

				for(s32 i=0; i<4; i++)
				{
					//vertices[i].Pos.Y += liquid_level;
					//vertices[i].Pos.Y += neighbor_levels[v3s16(0,0,0)];
					s32 j = corner_resolve[i];
					vertices[i].Pos.Y += corner_levels[j];
					vertices[i].Pos += intToFloat(p, BS);
				}

				// 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[side_corners[3][0]] +
						corner_levels[side_corners[3][1]]) -
						(corner_levels[side_corners[2][0]] +
						corner_levels[side_corners[2][1]]);
				// Positive if liquid moves towards +X
				f32 dx = (corner_levels[side_corners[1][0]] +
						corner_levels[side_corners[1][1]]) -
						(corner_levels[side_corners[0][0]] +
						corner_levels[side_corners[0][1]]);
				f32 tcoord_angle = atan2(dz, dx) * core::RADTODEG ;
				v2f tcoord_center(0.5, 0.5);
				v2f tcoord_translate(
						blockpos_nodes.Z + z,
						blockpos_nodes.X + x);
				tcoord_translate.rotateBy(tcoord_angle);
				tcoord_translate.X -= floor(tcoord_translate.X);
				tcoord_translate.Y -= floor(tcoord_translate.Y);

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

				v2f t = vertices[0].TCoords;
				vertices[0].TCoords = vertices[2].TCoords;
				vertices[2].TCoords = t;

				u16 indices[] = {0,1,2,2,3,0};
				// Add to mesh collector
				collector.append(tile_liquid, vertices, 4, indices, 6);
			}
		break;}
		case NDT_GLASSLIKE:
		{
			TileSpec tile = getNodeTile(n, p, v3s16(0,0,0), data);

			u16 l = getInteriorLight(n, 1, nodedef);
			video::SColor c = MapBlock_LightColor(255, l, f.light_source);

			for(u32 j=0; j<6; j++)
			{
				// Check this neighbor
				v3s16 dir = g_6dirs[j];
				v3s16 n2p = blockpos_nodes + p + dir;
				MapNode n2 = data->m_vmanip.getNodeNoEx(n2p);
				// Don't make face if neighbor is of same type
				if(n2.getContent() == n.getContent())
					continue;

				// The face at Z+
				video::S3DVertex vertices[4] = {
					video::S3DVertex(-BS/2,-BS/2,BS/2, dir.X,dir.Y,dir.Z, c, 1,1),
					video::S3DVertex(BS/2,-BS/2,BS/2, dir.X,dir.Y,dir.Z, c, 0,1),
					video::S3DVertex(BS/2,BS/2,BS/2, dir.X,dir.Y,dir.Z, c, 0,0),
					video::S3DVertex(-BS/2,BS/2,BS/2, dir.X,dir.Y,dir.Z, c, 1,0),
				};

				// Rotations in the g_6dirs format
				if(j == 0) // Z+
					for(u16 i=0; i<4; i++)
						vertices[i].Pos.rotateXZBy(0);
				else if(j == 1) // Y+
					for(u16 i=0; i<4; i++)
						vertices[i].Pos.rotateYZBy(-90);
				else if(j == 2) // X+
					for(u16 i=0; i<4; i++)
						vertices[i].Pos.rotateXZBy(-90);
				else if(j == 3) // Z-
					for(u16 i=0; i<4; i++)
						vertices[i].Pos.rotateXZBy(180);
				else if(j == 4) // Y-
					for(u16 i=0; i<4; i++)
						vertices[i].Pos.rotateYZBy(90);
				else if(j == 5) // X-
					for(u16 i=0; i<4; i++)
						vertices[i].Pos.rotateXZBy(90);

				for(u16 i=0; i<4; i++){
					vertices[i].Pos += intToFloat(p, BS);
				}

				u16 indices[] = {0,1,2,2,3,0};
				// Add to mesh collector
				collector.append(tile, vertices, 4, indices, 6);
			}
		break;}
		case NDT_GLASSLIKE_FRAMED_OPTIONAL:
			// This is always pre-converted to something else
			FATAL_ERROR("NDT_GLASSLIKE_FRAMED_OPTIONAL not pre-converted as expected");
			break;
		case NDT_GLASSLIKE_FRAMED:
		{
			static const v3s16 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)
			};

			u8 i;
			TileSpec tiles[6];
			for (i = 0; i < 6; i++)
				tiles[i] = getNodeTile(n, p, dirs[i], data);

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

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

			u16 l = getInteriorLight(n, 1, nodedef);
			video::SColor c = MapBlock_LightColor(255, l, f.light_source);
			v3f pos = intToFloat(p, BS);
			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[12] = {
				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), // y+
				aabb3f(-g,-g,-g, g,-g, g), // y-
				aabb3f( g,-g,-g, g, g, g), // x+
				aabb3f(-g,-g,-g,-g, g, g), // x-
				aabb3f(-g,-g, g, g, g, g), // z+
				aabb3f(-g,-g,-g, g, g,-g)  // z-
			};

			// table of node visible faces, 0 = invisible
			int visible_faces[6] = {0,0,0,0,0,0};

			// table of neighbours, 1 = same type, checked with g_26dirs
			int nb[18] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

			// g_26dirs to check when only horizontal merge is allowed
			int nb_H_dirs[8] = {0,2,3,5,10,11,12,13};

			content_t current = n.getContent();
			content_t n2c;
			MapNode n2;
			v3s16 n2p;

			// neighbours checks for frames visibility

			if (!H_merge && V_merge) {
				n2p = blockpos_nodes + p + g_26dirs[1];
				n2 = data->m_vmanip.getNodeNoEx(n2p);
				n2c = n2.getContent();
				if (n2c == current || n2c == CONTENT_IGNORE)
					nb[1] = 1;
				n2p = blockpos_nodes + p + g_26dirs[4];
				n2 = data->m_vmanip.getNodeNoEx(n2p);
				n2c = n2.getContent();
				if (n2c == current || n2c == CONTENT_IGNORE)
					nb[4] = 1;
			} else if (H_merge && !V_merge) {
				for(i = 0; i < 8; i++) {
					n2p = blockpos_nodes + p + g_26dirs[nb_H_dirs[i]];
					n2 = data->m_vmanip.getNodeNoEx(n2p);
					n2c = n2.getContent();
					if (n2c == current || n2c == CONTENT_IGNORE)
						nb[nb_H_dirs[i]] = 1;
				}
			} else if (H_merge && V_merge) {
				for(i = 0; i < 18; i++)	{
					n2p = blockpos_nodes + p + g_26dirs[i];
					n2 = data->m_vmanip.getNodeNoEx(n2p);
					n2c = n2.getContent();
					if (n2c == current || n2c == CONTENT_IGNORE)
						nb[i] = 1;
				}
			}

			// faces visibility checks

			if (!V_merge) {
				visible_faces[0] = 1;
				visible_faces[1] = 1;
			} else {
				for(i = 0; i < 2; i++) {
					n2p = blockpos_nodes + p + dirs[i];
					n2 = data->m_vmanip.getNodeNoEx(n2p);
					n2c = n2.getContent();
					if (n2c != current)
						visible_faces[i] = 1;
				}
			}

			if (!H_merge) {
				visible_faces[2] = 1;
				visible_faces[3] = 1;
				visible_faces[4] = 1;
				visible_faces[5] = 1;
			} else {
				for(i = 2; i < 6; i++) {
					n2p = blockpos_nodes + p + dirs[i];
					n2 = data->m_vmanip.getNodeNoEx(n2p);
					n2c = n2.getContent();
					if (n2c != current)
						visible_faces[i] = 1;
				}
			}

			static const u8 nb_triplet[12*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
			};

			f32 tx1, ty1, tz1, tx2, ty2, tz2;
			aabb3f box;

			for(i = 0; i < 12; i++)
			{
				int edge_invisible;
				if (nb[nb_triplet[i*3+2]])
					edge_invisible = nb[nb_triplet[i*3]] & nb[nb_triplet[i*3+1]];
				else
					edge_invisible = nb[nb_triplet[i*3]] ^ nb[nb_triplet[i*3+1]];
				if (edge_invisible)
					continue;
				box = frame_edges[i];
				box.MinEdge += pos;
				box.MaxEdge += pos;
				tx1 = (box.MinEdge.X / BS) + 0.5;
				ty1 = (box.MinEdge.Y / BS) + 0.5;
				tz1 = (box.MinEdge.Z / BS) + 0.5;
				tx2 = (box.MaxEdge.X / BS) + 0.5;
				ty2 = (box.MaxEdge.Y / BS) + 0.5;
				tz2 = (box.MaxEdge.Z / BS) + 0.5;
				f32 txc1[24] = {
					tx1,   1-tz2,   tx2, 1-tz1,
					tx1,     tz1,   tx2,   tz2,
					tz1,   1-ty2,   tz2, 1-ty1,
					1-tz2, 1-ty2, 1-tz1, 1-ty1,
					1-tx2, 1-ty2, 1-tx1, 1-ty1,
					tx1,   1-ty2,   tx2, 1-ty1,
				};
				makeCuboid(&collector, box, &tiles[0], 1, c, txc1);
			}

			for(i = 0; i < 6; i++)
			{
				if (!visible_faces[i])
					continue;
				box = glass_faces[i];
				box.MinEdge += pos;
				box.MaxEdge += pos;
				tx1 = (box.MinEdge.X / BS) + 0.5;
				ty1 = (box.MinEdge.Y / BS) + 0.5;
				tz1 = (box.MinEdge.Z / BS) + 0.5;
				tx2 = (box.MaxEdge.X / BS) + 0.5;
				ty2 = (box.MaxEdge.Y / BS) + 0.5;
				tz2 = (box.MaxEdge.Z / BS) + 0.5;
				f32 txc2[24] = {
					tx1,   1-tz2,   tx2, 1-tz1,
					tx1,     tz1,   tx2,   tz2,
					tz1,   1-ty2,   tz2, 1-ty1,
					1-tz2, 1-ty2, 1-tz1, 1-ty1,
					1-tx2, 1-ty2, 1-tx1, 1-ty1,
					tx1,   1-ty2,   tx2, 1-ty1,
				};
				makeCuboid(&collector, box, &glass_tiles[i], 1, c, txc2);
			}

			if (param2 > 0 && f.special_tiles[0].texture) {
				// Interior volume level is in range 0 .. 63,
				// convert it to -0.5 .. 0.5
				float vlev = (((float)param2 / 63.0 ) * 2.0 - 1.0);
				TileSpec interior_tiles[6];
				for (i = 0; i < 6; i++)
					interior_tiles[i] = f.special_tiles[0];
				float offset = 0.003;
				box = aabb3f(visible_faces[3] ? -b : -a + offset,
							 visible_faces[1] ? -b : -a + offset,
							 visible_faces[5] ? -b : -a + offset,
							 visible_faces[2] ? b : a - offset,
							 visible_faces[0] ? b * vlev : a * vlev - offset,
							 visible_faces[4] ? b : a - offset);
				box.MinEdge += pos;
				box.MaxEdge += pos;
				tx1 = (box.MinEdge.X / BS) + 0.5;
				ty1 = (box.MinEdge.Y / BS) + 0.5;
				tz1 = (box.MinEdge.Z / BS) + 0.5;
				tx2 = (box.MaxEdge.X / BS) + 0.5;
				ty2 = (box.MaxEdge.Y / BS) + 0.5;
				tz2 = (box.MaxEdge.Z / BS) + 0.5;
				f32 txc3[24] = {
					tx1,   1-tz2,   tx2, 1-tz1,
					tx1,     tz1,   tx2,   tz2,
					tz1,   1-ty2,   tz2, 1-ty1,
					1-tz2, 1-ty2, 1-tz1, 1-ty1,
					1-tx2, 1-ty2, 1-tx1, 1-ty1,
					tx1,   1-ty2,   tx2, 1-ty1,
				};
				makeCuboid(&collector, box, interior_tiles, 6, c,  txc3);
			}
		break;}
		case NDT_ALLFACES:
		{
			TileSpec tile_leaves = getNodeTile(n, p,
					v3s16(0,0,0), data);

			u16 l = getInteriorLight(n, 1, nodedef);
			video::SColor c = MapBlock_LightColor(255, l, f.light_source);

			v3f pos = intToFloat(p, BS);
			aabb3f box(-BS/2,-BS/2,-BS/2,BS/2,BS/2,BS/2);
			box.MinEdge += pos;
			box.MaxEdge += pos;
			makeCuboid(&collector, box, &tile_leaves, 1, c, NULL);
		break;}
		case NDT_ALLFACES_OPTIONAL:
			// This is always pre-converted to something else
			FATAL_ERROR("NDT_ALLFACES_OPTIONAL not pre-converted");
			break;
		case NDT_TORCHLIKE:
		{
			v3s16 dir = n.getWallMountedDir(nodedef);

			u8 tileindex = 0;
			if(dir == v3s16(0,-1,0)){
				tileindex = 0; // floor
			} else if(dir == v3s16(0,1,0)){
				tileindex = 1; // ceiling
			// For backwards compatibility
			} else if(dir == v3s16(0,0,0)){
				tileindex = 0; // floor
ofs	hex dump	ascii
0000	89 50 4e 47 0d 0a 1a 0a 00 00 00 0d 49 48 44 52 00 00 00 10 00 00 00 10 08 02 00 00 00 90 91 68	.PNG........IHDR...............h
0020	36 00 00 03 00 50 4c 54 45 00 00 00 ff 00 00 00 ff 00 ff ff 00 00 00 ff ff 00 ff 00 ff ff ff ff	6....PLTE.......................
0040	ff db db db b6 b6 b6 92 92 92 6d 6d 6d 49 49 49 24 24 24 db 00 00 b6 00 00 92 00 00 6d 00 00 49	..........mmmIII$$$.........m..I
0060	00 00 24 00 00 00 db 00 00 b6 00 00 92 00 00 6d 00 00 49 00 00 24 00 db db 00 b6 b6 00 92 92 00	..$............m..I..$..........
0080	6d 6d 00 49 49 00 24 24 00 00 00 db 00 00 b6 00 00 92 00 00 6d 00 00 49 00 00 24 db 00 db b6 00	mm.II.$$............m..I..$.....
00a0	b6 92 00 92 6d 00 6d 49 00 49 24 00 24 00 db db 00 b6 b6 00 92 92 00 6d 6d 00 49 49 00 24 24 ff	....m.mI.I$.$..........mm.II.$$.
00c0	db db db b6 b6 b6 92 92 92 6d 6d 6d 49 49 49 24 24 ff b6 b6 db 92 92 b6 6d 6d 92 49 49 6d 24 24	.........mmmIII$$.......mm.IIm$$
00e0	ff 92 92 db 6d 6d b6 49 49 92 24 24 ff 6d 6d db 49 49 b6 24 24 ff 49 49 db 24 24 ff 24 24 db ff	....mm.II.$$.mm.II.$$.II.$$.$$..
0100	db b6 db b6 92 b6 92 6d 92 6d 49 6d 49 24 49 24 b6 ff b6 92 db 92 6d b6 6d 49 92 49 24 6d 24 92	.......m.mImI$I$......m.mI.I$m$.
0120	ff 92 6d db 6d 49 b6 49 24 92 24 6d ff 6d 49 db 49 24 b6 24 49 ff 49 24 db 24 24 ff 24 db db ff	..m.mI.I$.$m.mI.I$.$I.I$.$$.$...
0140	b6 b6 db 92 92 b6 6d 6d 92 49 49 6d 24 24 49 b6 b6 ff 92 92 db 6d 6d b6 49 49 92 24 24 6d 92 92	......mm.IIm$$I......mm.II.$$m..
0160	ff 6d 6d db 49 49 b6 24 24 92 6d 6d ff 49 49 db 24 24 b6 49 49 ff 24 24 db 24 24 ff ff ff db db	.mm.II.$$.mm.II.$$.II.$$.$$.....
0180	db b6 b6 b6 92 92 92 6d 6d 6d 49 49 49 24 ff ff b6 db db 92 b6 b6 6d 92 92 49 6d 6d 24 ff ff 92	.......mmmIII$........m..Imm$...
01a0	db db 6d b6 b6 49 92 92 24 ff ff 6d db db 49 b6 b6 24 ff ff 49 db db 24 ff ff 24 ff db ff db b6	..m..I..$..m..I..$..I..$..$.....
01c0	db b6 92 b6 92 6d 92 6d 49 6d 49 24 49 ff b6 ff db 92 db b6 6d b6 92 49 92 6d 24 6d ff 92 ff db	.....m.mImI$I.......m..I.m$m....
01e0	6d db b6 49 b6 92 24 92 ff 6d ff db 49 db b6 24 b6 ff 49 ff db 24 db ff 24 ff db ff ff b6 db db	m..I..$..m..I..$..I..$..$.......
0200	92 b6 b6 6d 92 92 49 6d 6d 24 49 49 b6 ff ff 92 db db 6d b6 b6 49 92 92 24 6d 6d 92 ff ff 6d db	...m..Imm$II......m..I..$mm...m.
0220	db 49 b6 b6 24 92 92 6d ff ff 49 db db 24 b6 b6 49 ff ff 24 db db 24 ff ff ff db b6 db b6 92 b6	.I..$..m..I..$..I..$..$.........
0240	92 6d 92 6d 49 6d 49 24 49 24 00 ff b6 92 db 92 6d b6 6d 49 92 49 24 6d 24 00 ff b6 db db 92 b6	.m.mImI$I$......m.mI.I$m$.......
0260	b6 6d 92 92 49 6d 6d 24 49 49 00 24 ff 92 b6 db 6d 92 b6 49 6d 92 24 49 6d 00 24 db b6 ff b6 92	.m..Imm$II.$....m..Im.$Im.$.....
0280	db 92 6d b6 6d 49 92 49 24 6d 24 00 49 b6 92 ff 92 6d db 6d 49 b6 49 24 92 24 00 6d b6 db ff 92	..m.mI.I$m$.I....m.mI.I$.$.m....
02a0	b6 db 6d 92 b6 49 6d 92 24 49 6d 00 24 49 92 b6 ff 6d 92 db 49 6d b6 24 49 92 00 24 6d b6 ff db	..m..Im.$Im.$I...m..Im.$I..$m...
02c0	92 db b6 6d b6 92 49 92 6d 24 6d 49 00 49 24 92 ff b6 6d db 92 49 b6 6d 24 92 49 00 6d 24 db ff	...m..I.m$mI.I$...m..I.m$.I.m$..
02e0	b6 b6 db 92 92 b6 6d 6d 92 49 49 6d 24 24 49 00 b6 ff 92 92 db 6d 6d b6 49 49 92 24 24 6d 00 ff	......mm.IIm$$I......mm.II.$$m..
0300	b6 00 db 92 00 b6 6d 00 92 49 00 ff 00 b6 db 00 92 b6 00 6d 92 00 49 00 b6 ff 00 92 db 00 6d b6	......m..I.........m..I.......m.
0320	00 49 92 00 00 00 00 00 00 cf 2a 02 04 00 00 02 ed 49 44 41 54 28 cf 05 c1 db 6e db 64 00 00 60	.I........*......IDAT(....n.d..`
0340	fb ff 63 27 76 1c e7 e8 26 ab dd 1c 9a 43 bb 1c 26 25 85 88 ae a8 20 41 06 88 8b 4d 08 6e 06 12	..c'v...&....C..&%.....A...M.n..
0360	e2 b1 b8 41 e2 25 d8 24 2e 2a 98 34 c6 5a 60 24 6d ba 24 66 4d 9b c4 cd d1 76 5c 3b f1 39 7c 1f	...A.%.$.*.4.Z`$m.$fM....v\;.9\|.
0380	fa f5 e7 71 0c 43 a7 92 93 c8 ce 70 81 5b db 4e 26 59 6b 5f 3f db 49 1f fa 43 03 a0 70 e1 94 af	...q.C.....p.[.N&Yk_?.I..C..p...
03a0	d5 ea 39 53 12 b5 de ad 91 18 3c 7a 2f 0f 5d 31 4f a3 21 ab 48 26 df 06 02 b4 bb 14 a3 ac 15 09	..9S......<z/.]1O.!.H&..........
03c0	94 8c 29 75 33 e2 7d 91 18 97 39 b0 f4 cb 33 61 53 da 27 c1 c0 33 57 a7 9b a5 c3 d0 6c 2b 48 7c	..)u3.}...9...3aS.'..3W.....l+H\|
03e0	77 3d 14 a9 cc 91 c7 fb d9 f3 ee 4b 6f 44 bb 59 4b fe b0 7f 75 c3 93 06 51 df af 5a 40 03 04 6f	w=.........KoD.YK...u...Q..Z@..o
0400	df a2 a6 57 55 b4 40 4a 19 9d e4 2a 0f 55 55 65 f6 b8 06 67 8d c7 b7 df 34 2a 93 e6 f5 36 45 8f	...WU.@J....UUe...g....4...6E.
0420	27 9b 7c 12 ed f3 00 e6 f6 55 b6 bc 7d d9 d5 82 1e 52 b9 18 ef a7 e2 6b f1 ef bf 9e 9f 8e 6d fc	'.\|......U..}....R.....k......m.
0440	2d b2 38 fd e5 8e 2a 55 88 a0 50 2a ee 3d 3b 7b b5 3b 03 30 cd 16 10 37 f4 f8 ab 1f 66 37 62 b8	-.8...U..P.=;{.;.0...7....f7b.
0460	da 13 64 1a b2 00 47 d8 9d 6c d6 1c 9b 5c 04 14 53 e8 8f 3f 77 8c c9 b2 f1 e9 d3 37 7a 13 7e ff	..d...G..l...\..S..?w......7z.~.
0480	e4 48 97 9b 0b 7b 03 ef fe 7c f3 0e 1b da 6b bb 6b 76 47 4a bb 23 48 b2 91 28 50 33 45 c3 1c f7	.H...{...\|....k.kvGJ.#H..(P3E...
04a0	a3 c6 17 23 e9 77 36 c1 c0 62 34 ae 22 ce c9 1f bd 46 ad 7e d2 e9 e7 6c da eb 85 32 bc 2b 73 24	...#.w6..b4."....F.~...l...2.+s$
04c0	13 42 36 4e 32 66 4a f7 8e eb a8 74 ba 98 48 bf bd e8 c1 6d 6c 75 2e 0c 58 3a fa b2 f9 df 97 8f	.B6N2fJ....t..H....mlu..X:......
04e0	2a 1a 29 fb d3 44 15 62 fe a8 35 17 83 e7 17 a3 a7 9f d4 c6 83 d7 21 ec 81 c1 cf 61 dc 86 c7 d5	*.)..D.b..5...........!....a....
0500	34 12 5c 85 e9 98 ba 91 5a ff 68 fe 18 b8 3c 13 b6 bc 81 a1 0a c8 f2 f6 b1 cf f3 53 b3 b9 b7 93	4.\.....Z.h...<............S....
0520	b5 7d de 05 b8 cc 47 6b b0 94 64 a2 34 90 a7 20 e2 01 54 50 a6 5c bd 10 89 77 91 a1 b2 b2 fd c2	.}....Gk..d.4.....TP.\...w......
0540	8a 37 e4 ca c3 18 b1 00 93 e5 b8 c8 14 85 c9 15 8c 67 dd 1c c9 65 76 31 3c 26 ed 80 14 17 c9 b9	.7...............g...ev1<&......
0560	7d 9d 2b e7 34 d1 ae 1f d7 95 5e 8f f6 a9 6c e5 f0 0e d9 f4 87 c2 4a 30 e0 b7 1f df ff 77 c4 bf	}.+.4.....^...l.......J0.....w..
0580	e8 cd 3f 84 1c 9a c1 e5 50 20 5d 8a 2b bf 5e a5 0a 33 74 66 51 65 92 40 68 c7 b2 ef fb 99 f6 b9	..?.....P.].+.^..3tfQe.@h.......
05a0	ca 53 3a fc 20 4b f0 d7 70 8f dd 72 10 7d a4 08 62 c7 69 0d 5f 15 6a 07 36 8e 3b b8 3e e1 01 91	.S:..K..p..r.}..b.i._.j.6.;.>...
05c0	ad b6 3b 7c 3b 61 eb f2 38 1d 5e c3 f7 73 b4 74 35 39 7c 94 41 22 d8 3d 33 8f 10 17 18 0e b6 36	..;\|;a..8.^..s.t59\|.A".=3......6
05e0	a6 2c 2f bd 07 55 53 bc 9d 0c 3a 9b 29 7e d5 d6 53 87 09 52 4c c3 07 b5 14 9b 64 d6 96 e0 33 bc	.,/..US...:.)~..S..RL.....d...3.
0600	af fb 22 e5 b8 2b 18 70 ad 68 6a 37 33 1f e0 50 6b 1b 86 8a 90 3e 12 63 c0 14 a1 cc e5 ff 1a 78	.."..+.p.hj73..Pk....>.c.......x
0620	72 6b ea 29 29 f1 00 00 00 00 49 45 4e 44 ae 42 60 82	rk.)).....IEND.B`.