aboutsummaryrefslogtreecommitdiff
path: root/src/script/cpp_api
Commit message (Expand)AuthorAge
* Fix minetest.dig_node returning true when node isn't diggable (#10890)rubenwardy2021-01-31
* Rework use_texture_alpha to provide three opaque/clip/blend modessfan52021-01-29
* Remove dead code (#10845)rubenwardy2021-01-22
* Implement on_rightclickplayer callback (#10775)JDiaz2021-01-11
* Add on_deactivate callback for luaentities (#10723)hecks2021-01-02
* Fix some minor code issues all over the placesfan52020-12-24
* Fix CSMs on arm64 (#10553)luk3yx2020-10-25
* Fix Lua panic when error() message is not a stringPaul Ouellette2020-06-07
* Value copy / allocation optimizations mostly in server, SAO and serialize codesfan52020-05-27
* Add on_authplayer callback and 'last_login' to on_joinplayer (#9574)sorcerykid2020-05-23
* Expose collision information to LuaEntity on_stepsfan52020-04-27
* script: Put getGuiEngine() inside a client-only #ifdefsfan52020-04-27
* Drop content_sao.{cpp,h}Loic Blot2020-04-11
* Move PlayerSAO to dedicated filesLoic Blot2020-04-11
* Move serveractiveobject & unitsaoLoic Blot2020-04-11
* Work around LuaJIT issues on aarch64 (#9614)sfan52020-04-08
* Overall improvements to log messages (#9598)sfan52020-04-08
* Script API: Document ObjectRef handling in a commentsfan52020-02-23
* [CSM] Expose more env functionssfan52019-11-11
* Call on_secondary_use when object is right-clickedsfan52019-11-10
* Load client mods into memory before execution.sfan52019-11-09
* Refactor loading of Lua code with mod securitysfan52019-11-09
* CSM: Fix itemstack:get_meta() 'metadata' indexing errorSmallJoker2019-09-14
* Load CSM environment after the restrictions are knownSmallJoker2019-09-14
* Merge pull request #8776 from osjc/FixGetNodeJozef Behran2019-08-10
* Allow customizing chat message format (#8529)ANAND2019-08-08
* Move the clamping of hp/breath when their maximums change to read_object_prop...Beha2019-07-30
* Check for 'action' field in ABMs & LBMsSmallJoker2019-07-27
* Removed debug.upvaluejoin to prevent leak of insecure environmenty2019-07-24
* Add node field to PlayerHPChangeReason table (#8368)Paul Ouellette2019-04-11
* HPChange Reason: Fix push after free, and type being overwritten (#8359)rubenwardy2019-03-12
* Consistent HP and damage types (#8167)SmallJoker2019-02-10
* Fix wrong code comment (#8061)DS2019-01-06
* Move client-specific files to 'src/client' (#7902)Quentin Bazin2018-11-28
* Raycast: export exact pointing location (#6304)Dániel Juhász2018-08-16
* Add a MSVC / Windows compatible snprintf function (#7353)nOOb31672018-07-22
* Modernize lua read (part 2 & 3): C++ templating assurance (#7410)Loïc Blot2018-06-30
* CSM/SSM: Add on_mods_loaded callback (#7411)Loïc Blot2018-06-06
* Fix builtin inventory list crash when size = 0 (#7297)SmallJoker2018-05-05
* Allow damage for attached objects, add attach/detach callbacks (#6786)SmallJoker2018-04-30
* Add online content repositoryrubenwardy2018-04-19
* Run callback in IDropAction, refactor function argumentsSmallJoker2018-04-02
* Add player inventory callbacksSmallJoker2018-04-02
* LINT: add clang-tidy step (#6295)Loïc Blot2018-04-01
* Fix a warning reported by clangLoic Blot2018-03-29
* Add reasons to on_dieplayer and on_hpchangeAndrew Ward2018-03-28
* Add `on_auth_fail` callback (#7039)red-0012018-02-15
* Node definition manager refactor (#7016)Dániel Juhász2018-02-10
* Move `setlocale` from Lua to C++.red-0012018-02-08
* [CSM] Don't Load the package library (#6944)red-0012018-01-22
458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969
/*
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 "inventory.h"
#include "serialization.h"
#include "debug.h"
#include <sstream>
#include "log.h"
#include "itemdef.h"
#include "util/strfnd.h"
#include "content_mapnode.h" // For loading legacy MaterialItems
#include "nameidmapping.h" // For loading legacy MaterialItems
#include "util/serialize.h"
#include "util/string.h"

/*
	ItemStack
*/

static content_t content_translate_from_19_to_internal(content_t c_from)
{
	for (const auto &tt : trans_table_19) {
		if(tt[1] == c_from) {
			return tt[0];
		}
	}
	return c_from;
}

ItemStack::ItemStack(const std::string &name_, u16 count_,
		u16 wear_, IItemDefManager *itemdef) :
	name(itemdef->getAlias(name_)),
	count(count_),
	wear(wear_)
{
	if (name.empty() || count == 0)
		clear();
	else if (itemdef->get(name).type == ITEM_TOOL)
		count = 1;
}

void ItemStack::serialize(std::ostream &os) const
{
	if (empty())
		return;

	// Check how many parts of the itemstring are needed
	int parts = 1;
	if(count != 1)
		parts = 2;
	if(wear != 0)
		parts = 3;
	if (!metadata.empty())
		parts = 4;

	os<<serializeJsonStringIfNeeded(name);
	if(parts >= 2)
		os<<" "<<count;
	if(parts >= 3)
		os<<" "<<wear;
	if (parts >= 4) {
		os << " ";
		metadata.serialize(os);
	}
}

void ItemStack::deSerialize(std::istream &is, IItemDefManager *itemdef)
{
	clear();

	// Read name
	name = deSerializeJsonStringIfNeeded(is);

	// Skip space
	std::string tmp;
	std::getline(is, tmp, ' ');
	if(!tmp.empty())
		throw SerializationError("Unexpected text after item name");

	if(name == "MaterialItem")
	{
		// Obsoleted on 2011-07-30

		u16 material;
		is>>material;
		u16 materialcount;
		is>>materialcount;
		// Convert old materials
		if(material <= 0xff)
			material = content_translate_from_19_to_internal(material);
		if(material > 0xfff)
			throw SerializationError("Too large material number");
		// Convert old id to name
		NameIdMapping legacy_nimap;
		content_mapnode_get_name_id_mapping(&legacy_nimap);
		legacy_nimap.getName(material, name);
		if(name.empty())
			name = "unknown_block";
		if (itemdef)
			name = itemdef->getAlias(name);
		count = materialcount;
	}
	else if(name == "MaterialItem2")
	{
		// Obsoleted on 2011-11-16

		u16 material;
		is>>material;
		u16 materialcount;
		is>>materialcount;
		if(material > 0xfff)
			throw SerializationError("Too large material number");
		// Convert old id to name
		NameIdMapping legacy_nimap;
		content_mapnode_get_name_id_mapping(&legacy_nimap);
		legacy_nimap.getName(material, name);
		if(name.empty())
			name = "unknown_block";
		if (itemdef)
			name = itemdef->getAlias(name);
		count = materialcount;
	}
	else if(name == "node" || name == "NodeItem" || name == "MaterialItem3"
			|| name == "craft" || name == "CraftItem")
	{
		// Obsoleted on 2012-01-07

		std::string all;
		std::getline(is, all, '\n');
		// First attempt to read inside ""
		Strfnd fnd(all);
		fnd.next("\"");
		// If didn't skip to end, we have ""s
		if(!fnd.at_end()){
			name = fnd.next("\"");
		} else { // No luck, just read a word then
			fnd.start(all);
			name = fnd.next(" ");
		}
		fnd.skip_over(" ");
		if (itemdef)
			name = itemdef->getAlias(name);
		count = stoi(trim(fnd.next("")));
		if(count == 0)
			count = 1;
	}
	else if(name == "MBOItem")
	{
		// Obsoleted on 2011-10-14
		throw SerializationError("MBOItem not supported anymore");
	}
	else if(name == "tool" || name == "ToolItem")
	{
		// Obsoleted on 2012-01-07

		std::string all;
		std::getline(is, all, '\n');
		// First attempt to read inside ""
		Strfnd fnd(all);
		fnd.next("\"");
		// If didn't skip to end, we have ""s
		if(!fnd.at_end()){
			name = fnd.next("\"");
		} else { // No luck, just read a word then
			fnd.start(all);
			name = fnd.next(" ");
		}
		count = 1;
		// Then read wear
		fnd.skip_over(" ");
		if (itemdef)
			name = itemdef->getAlias(name);
		wear = stoi(trim(fnd.next("")));
	}
	else
	{
		do  // This loop is just to allow "break;"
		{
			// The real thing

			// Apply item aliases
			if (itemdef)
				name = itemdef->getAlias(name);

			// Read the count
			std::string count_str;
			std::getline(is, count_str, ' ');
			if (count_str.empty()) {
				count = 1;
				break;
			}

			count = stoi(count_str);

			// Read the wear
			std::string wear_str;
			std::getline(is, wear_str, ' ');
			if(wear_str.empty())
				break;

			wear = stoi(wear_str);

			// Read metadata
			metadata.deSerialize(is);

			// In case fields are added after metadata, skip space here:
			//std::getline(is, tmp, ' ');
			//if(!tmp.empty())
			//	throw SerializationError("Unexpected text after metadata");

		} while(false);
	}

	if (name.empty() || count == 0)
		clear();
	else if (itemdef && itemdef->get(name).type == ITEM_TOOL)
		count = 1;
}

void ItemStack::deSerialize(const std::string &str, IItemDefManager *itemdef)
{
	std::istringstream is(str, std::ios::binary);
	deSerialize(is, itemdef);
}

std::string ItemStack::getItemString() const
{
	std::ostringstream os(std::ios::binary);
	serialize(os);
	return os.str();
}


ItemStack ItemStack::addItem(ItemStack newitem, IItemDefManager *itemdef)
{
	// If the item is empty or the position invalid, bail out
	if(newitem.empty())
	{
		// nothing can be added trivially
	}
	// If this is an empty item, it's an easy job.
	else if(empty())
	{
		const u16 stackMax = newitem.getStackMax(itemdef);

		*this = newitem;

		// If the item fits fully, delete it
		if (count <= stackMax) {
			newitem.clear();
		} else { // Else the item does not fit fully. Return the rest.
			count = stackMax;
			newitem.remove(count);
		}
	}
	// If item name or metadata differs, bail out
	else if (name != newitem.name
		|| metadata != newitem.metadata)
	{
		// cannot be added
	}
	// If the item fits fully, add counter and delete it
	else if(newitem.count <= freeSpace(itemdef))
	{
		add(newitem.count);
		newitem.clear();
	}
	// Else the item does not fit fully. Add all that fits and return
	// the rest.
	else
	{
		u16 freespace = freeSpace(itemdef);
		add(freespace);
		newitem.remove(freespace);
	}

	return newitem;
}

bool ItemStack::itemFits(ItemStack newitem,
		ItemStack *restitem,
		IItemDefManager *itemdef) const
{

	// If the item is empty or the position invalid, bail out
	if(newitem.empty())
	{
		// nothing can be added trivially
	}
	// If this is an empty item, it's an easy job.
	else if(empty())
	{
		const u16 stackMax = newitem.getStackMax(itemdef);

		// If the item fits fully, delete it
		if (newitem.count <= stackMax) {
			newitem.clear();
		} else { // Else the item does not fit fully. Return the rest.
			newitem.remove(stackMax);
		}
	}
	// If item name or metadata differs, bail out
	else if (name != newitem.name
		|| metadata != newitem.metadata)
	{
		// cannot be added
	}
	// If the item fits fully, delete it
	else if(newitem.count <= freeSpace(itemdef))
	{
		newitem.clear();
	}
	// Else the item does not fit fully. Return the rest.
	else
	{
		u16 freespace = freeSpace(itemdef);
		newitem.remove(freespace);
	}

	if(restitem)
		*restitem = newitem;
	return newitem.empty();
}

ItemStack ItemStack::takeItem(u32 takecount)
{
	if(takecount == 0 || count == 0)
		return ItemStack();

	ItemStack result = *this;
	if(takecount >= count)
	{
		// Take all
		clear();
	}
	else
	{
		// Take part
		remove(takecount);
		result.count = takecount;
	}
	return result;
}

ItemStack ItemStack::peekItem(u32 peekcount) const
{
	if(peekcount == 0 || count == 0)
		return ItemStack();

	ItemStack result = *this;
	if(peekcount < count)
		result.count = peekcount;
	return result;
}

/*
	Inventory
*/

InventoryList::InventoryList(const std::string &name, u32 size, IItemDefManager *itemdef):
	m_name(name),
	m_size(size),
	m_itemdef(itemdef)
{
	clearItems();
}

void InventoryList::clearItems()
{
	m_items.clear();

	for (u32 i=0; i < m_size; i++) {
		m_items.emplace_back();
	}

	//setDirty(true);
}

void InventoryList::setSize(u32 newsize)
{
	if(newsize != m_items.size())
		m_items.resize(newsize);
	m_size = newsize;
}

void InventoryList::setWidth(u32 newwidth)
{
	m_width = newwidth;
}

void InventoryList::setName(const std::string &name)
{
	m_name = name;
}

void InventoryList::serialize(std::ostream &os) const
{
	//os.imbue(std::locale("C"));

	os<<"Width "<<m_width<<"\n";

	for (const auto &item : m_items) {
		if (item.empty()) {
			os<<"Empty";
		} else {
			os<<"Item ";
			item.serialize(os);
		}
		os<<"\n";
	}

	os<<"EndInventoryList\n";
}

void InventoryList::deSerialize(std::istream &is)
{
	//is.imbue(std::locale("C"));

	clearItems();
	u32 item_i = 0;
	m_width = 0;

	for(;;)
	{
		std::string line;
		std::getline(is, line, '\n');

		std::istringstream iss(line);
		//iss.imbue(std::locale("C"));

		std::string name;
		std::getline(iss, name, ' ');

		if (name == "EndInventoryList") {
			break;
		}

		// This is a temporary backwards compatibility fix
		if (name == "end") {
			break;
		}

		if (name == "Width") {
			iss >> m_width;
			if (iss.fail())
				throw SerializationError("incorrect width property");
		}
		else if(name == "Item")
		{
			if(item_i > getSize() - 1)
				throw SerializationError("too many items");
			ItemStack item;
			item.deSerialize(iss, m_itemdef);
			m_items[item_i++] = item;
		}
		else if(name == "Empty")
		{
			if(item_i > getSize() - 1)
				throw SerializationError("too many items");
			m_items[item_i++].clear();
		}
	}
}

InventoryList::InventoryList(const InventoryList &other)
{
	*this = other;
}

InventoryList & InventoryList::operator = (const InventoryList &other)
{
	m_items = other.m_items;
	m_size = other.m_size;
	m_width = other.m_width;
	m_name = other.m_name;
	m_itemdef = other.m_itemdef;
	//setDirty(true);

	return *this;
}

bool InventoryList::operator == (const InventoryList &other) const
{
	if(m_size != other.m_size)
		return false;
	if(m_width != other.m_width)
		return false;
	if(m_name != other.m_name)
		return false;
	for(u32 i=0; i<m_items.size(); i++)
	{
		ItemStack s1 = m_items[i];
		ItemStack s2 = other.m_items[i];
		if(s1.name != s2.name || s1.wear!= s2.wear || s1.count != s2.count ||
				s1.metadata != s2.metadata)
			return false;
	}

	return true;
}

const std::string &InventoryList::getName() const
{
	return m_name;
}

u32 InventoryList::getSize() const
{
	return m_items.size();
}

u32 InventoryList::getWidth() const
{
	return m_width;
}

u32 InventoryList::getUsedSlots() const
{
	u32 num = 0;
	for (const auto &m_item : m_items) {
		if (!m_item.empty())
			num++;
	}
	return num;
}

u32 InventoryList::getFreeSlots() const
{
	return getSize() - getUsedSlots();
}

const ItemStack& InventoryList::getItem(u32 i) const
{
	assert(i < m_size); // Pre-condition
	return m_items[i];
}

ItemStack& InventoryList::getItem(u32 i)
{
	assert(i < m_size); // Pre-condition
	return m_items[i];
}

ItemStack InventoryList::changeItem(u32 i, const ItemStack &newitem)
{
	if(i >= m_items.size())
		return newitem;

	ItemStack olditem = m_items[i];
	m_items[i] = newitem;
	//setDirty(true);
	return olditem;
}

void InventoryList::deleteItem(u32 i)
{
	assert(i < m_items.size()); // Pre-condition
	m_items[i].clear();
}

ItemStack InventoryList::addItem(const ItemStack &newitem_)
{
	ItemStack newitem = newitem_;

	if(newitem.empty())
		return newitem;

	/*
		First try to find if it could be added to some existing items
	*/
	for(u32 i=0; i<m_items.size(); i++)
	{
		// Ignore empty slots
		if(m_items[i].empty())
			continue;
		// Try adding
		newitem = addItem(i, newitem);
		if(newitem.empty())
			return newitem; // All was eaten
	}

	/*
		Then try to add it to empty slots
	*/
	for(u32 i=0; i<m_items.size(); i++)
	{
		// Ignore unempty slots
		if(!m_items[i].empty())
			continue;
		// Try adding
		newitem = addItem(i, newitem);
		if(newitem.empty())
			return newitem; // All was eaten
	}

	// Return leftover
	return newitem;
}

ItemStack InventoryList::addItem(u32 i, const ItemStack &newitem)
{
	if(i >= m_items.size())
		return newitem;

	ItemStack leftover = m_items[i].addItem(newitem, m_itemdef);
	//if(leftover != newitem)
	//	setDirty(true);
	return leftover;
}

bool InventoryList::itemFits(const u32 i, const ItemStack &newitem,
		ItemStack *restitem) const
{
	if(i >= m_items.size())
	{
		if(restitem)
			*restitem = newitem;
		return false;
	}

	return m_items[i].itemFits(newitem, restitem, m_itemdef);
}

bool InventoryList::roomForItem(const ItemStack &item_) const
{
	ItemStack item = item_;
	ItemStack leftover;
	for(u32 i=0; i<m_items.size(); i++)
	{
		if(itemFits(i, item, &leftover))
			return true;
		item = leftover;
	}
	return false;
}

bool InventoryList::containsItem(const ItemStack &item, bool match_meta) const
{
	u32 count = item.count;
	if (count == 0)
		return true;

	for (auto i = m_items.rbegin(); i != m_items.rend(); ++i) {
		if (count == 0)
			break;
		if (i->name == item.name && (!match_meta || (i->metadata == item.metadata))) {
			if (i->count >= count)
				return true;

			count -= i->count;
		}
	}
	return false;
}

ItemStack InventoryList::removeItem(const ItemStack &item)
{
	ItemStack removed;
	for (auto i = m_items.rbegin(); i != m_items.rend(); ++i) {
		if (i->name == item.name) {
			u32 still_to_remove = item.count - removed.count;
			removed.addItem(i->takeItem(still_to_remove), m_itemdef);
			if (removed.count == item.count)
				break;
		}
	}
	return removed;
}

ItemStack InventoryList::takeItem(u32 i, u32 takecount)
{
	if(i >= m_items.size())
		return ItemStack();

	ItemStack taken = m_items[i].takeItem(takecount);
	//if(!taken.empty())
	//	setDirty(true);
	return taken;
}

void InventoryList::moveItemSomewhere(u32 i, InventoryList *dest, u32 count)
{
	// Take item from source list
	ItemStack item1;
	if (count == 0)
		item1 = changeItem(i, ItemStack());
	else
		item1 = takeItem(i, count);

	if (item1.empty())
		return;

	// Try to add the item to destination list
	u32 dest_size = dest->getSize();
	// First try all the non-empty slots
	for (u32 dest_i = 0; dest_i < dest_size; dest_i++) {
		if (!m_items[dest_i].empty()) {
			item1 = dest->addItem(dest_i, item1);
			if (item1.empty()) return;
		}
	}

	// Then try all the empty ones
	for (u32 dest_i = 0; dest_i < dest_size; dest_i++) {
		if (m_items[dest_i].empty()) {
			item1 = dest->addItem(dest_i, item1);
			if (item1.empty()) return;
		}
	}

	// If we reach this, the item was not fully added
	// Add the remaining part back to the source item
	addItem(i, item1);
}

u32 InventoryList::moveItem(u32 i, InventoryList *dest, u32 dest_i,
		u32 count, bool swap_if_needed, bool *did_swap)
{
	if(this == dest && i == dest_i)
		return count;

	// Take item from source list
	ItemStack item1;
	if(count == 0)
		item1 = changeItem(i, ItemStack());
	else
		item1 = takeItem(i, count);

	if(item1.empty())
		return 0;

	// Try to add the item to destination list
	u32 oldcount = item1.count;
	item1 = dest->addItem(dest_i, item1);

	// If something is returned, the item was not fully added
	if(!item1.empty())
	{
		// If olditem is returned, nothing was added.
		bool nothing_added = (item1.count == oldcount);

		// If something else is returned, part of the item was left unadded.
		// Add the other part back to the source item
		addItem(i, item1);

		// If olditem is returned, nothing was added.
		// Swap the items
		if (nothing_added && swap_if_needed) {
			// Tell that we swapped
			if (did_swap != NULL) {
				*did_swap = true;
			}
			// Take item from source list
			item1 = changeItem(i, ItemStack());
			// Adding was not possible, swap the items.
			ItemStack item2 = dest->changeItem(dest_i, item1);
			// Put item from destination list to the source list
			changeItem(i, item2);
		}
	}
	return (oldcount - item1.count);
}

/*
	Inventory
*/

Inventory::~Inventory()
{
	clear();
}

void Inventory::clear()
{
	m_dirty = true;
	for (auto &m_list : m_lists) {
		delete m_list;
	}
	m_lists.clear();
}

void Inventory::clearContents()
{
	m_dirty = true;
	for (InventoryList *list : m_lists) {
		for (u32 j=0; j<list->getSize(); j++) {
			list->deleteItem(j);
		}
	}
}

Inventory::Inventory(IItemDefManager *itemdef)
{
	m_dirty = false;
	m_itemdef = itemdef;
}

Inventory::Inventory(const Inventory &other)
{
	*this = other;
	m_dirty = false;
}

Inventory & Inventory::operator = (const Inventory &other)
{
	// Gracefully handle self assignment
	if(this != &other)
	{
		m_dirty = true;
		clear();
		m_itemdef = other.m_itemdef;
		for (InventoryList *list : other.m_lists) {
			m_lists.push_back(new InventoryList(*list));
		}
	}
	return *this;
}

bool Inventory::operator == (const Inventory &other) const
{
	if(m_lists.size() != other.m_lists.size())
		return false;

	for(u32 i=0; i<m_lists.size(); i++)
	{
		if(*m_lists[i] != *other.m_lists[i])
			return false;
	}
	return true;
}

void Inventory::serialize(std::ostream &os) const
{
	for (InventoryList *list : m_lists) {
		os<<"List "<<list->getName()<<" "<<list->getSize()<<"\n";
		list->serialize(os);
	}

	os<<"EndInventory\n";
}

void Inventory::deSerialize(std::istream &is)
{
	clear();

	for(;;)
	{
		std::string line;
		std::getline(is, line, '\n');

		std::istringstream iss(line);

		std::string name;
		std::getline(iss, name, ' ');

		if (name == "EndInventory") {
			break;
		}

		// This is a temporary backwards compatibility fix
		if (name == "end") {
			break;
		}

		if (name == "List") {
			std::string listname;
			u32 listsize;

			std::getline(iss, listname, ' ');
			iss>>listsize;

			InventoryList *list = new InventoryList(listname, listsize, m_itemdef);
			list->deSerialize(is);

			m_lists.push_back(list);
		}
		else
		{
			throw SerializationError("invalid inventory specifier: " + name);
		}
	}
}

InventoryList * Inventory::addList(const std::string &name, u32 size)
{
	m_dirty = true;
	s32 i = getListIndex(name);
	if(i != -1)
	{
		if(m_lists[i]->getSize() != size)
		{
			delete m_lists[i];
			m_lists[i] = new InventoryList(name, size, m_itemdef);
		}
		return m_lists[i];
	}


	//don't create list with invalid name
	if (name.find(' ') != std::string::npos) return NULL;

	InventoryList *list = new InventoryList(name, size, m_itemdef);
	m_lists.push_back(list);
	return list;
}

InventoryList * Inventory::getList(const std::string &name)
{
	s32 i = getListIndex(name);
	if(i == -1)
		return NULL;
	return m_lists[i];
}

std::vector<const InventoryList*> Inventory::getLists()
{
	std::vector<const InventoryList*> lists;
	for (auto list : m_lists) {
		lists.push_back(list);
	}
	return lists;
}

bool Inventory::deleteList(const std::string &name)
{
	s32 i = getListIndex(name);
	if(i == -1)
		return false;
	m_dirty = true;
	delete m_lists[i];
	m_lists.erase(m_lists.begin() + i);
	return true;
}

const InventoryList * Inventory::getList(const std::string &name) const
{
	s32 i = getListIndex(name);
	if(i == -1)
		return NULL;
	return m_lists[i];
}

const s32 Inventory::getListIndex(const std::string &name) const
{
	for(u32 i=0; i<m_lists.size(); i++)
	{
		if(m_lists[i]->getName() == name)
			return i;
	}
	return -1;
}

//END
an> 1, 0, video::SColor(), txc[2], txc[1]), video::S3DVertex(max.X, max.Y, min.Z, 0, 1, 0, video::SColor(), txc[2], txc[3]), video::S3DVertex(min.X, max.Y, min.Z, 0, 1, 0, video::SColor(), txc[0], txc[3]), // down video::S3DVertex(min.X, min.Y, min.Z, 0, -1, 0, video::SColor(), txc[4], txc[5]), video::S3DVertex(max.X, min.Y, min.Z, 0, -1, 0, video::SColor(), txc[6], txc[5]), video::S3DVertex(max.X, min.Y, max.Z, 0, -1, 0, video::SColor(), txc[6], txc[7]), video::S3DVertex(min.X, min.Y, max.Z, 0, -1, 0, video::SColor(), txc[4], txc[7]), // right video::S3DVertex(max.X, max.Y, min.Z, 1, 0, 0, video::SColor(), txc[ 8], txc[9]), video::S3DVertex(max.X, max.Y, max.Z, 1, 0, 0, video::SColor(), txc[10], txc[9]), video::S3DVertex(max.X, min.Y, max.Z, 1, 0, 0, video::SColor(), txc[10], txc[11]), video::S3DVertex(max.X, min.Y, min.Z, 1, 0, 0, video::SColor(), txc[ 8], txc[11]), // left video::S3DVertex(min.X, max.Y, max.Z, -1, 0, 0, video::SColor(), txc[12], txc[13]), video::S3DVertex(min.X, max.Y, min.Z, -1, 0, 0, video::SColor(), txc[14], txc[13]), video::S3DVertex(min.X, min.Y, min.Z, -1, 0, 0, video::SColor(), txc[14], txc[15]), video::S3DVertex(min.X, min.Y, max.Z, -1, 0, 0, video::SColor(), txc[12], txc[15]), // back video::S3DVertex(max.X, max.Y, max.Z, 0, 0, 1, video::SColor(), txc[16], txc[17]), video::S3DVertex(min.X, max.Y, max.Z, 0, 0, 1, video::SColor(), txc[18], txc[17]), video::S3DVertex(min.X, min.Y, max.Z, 0, 0, 1, video::SColor(), txc[18], txc[19]), video::S3DVertex(max.X, min.Y, max.Z, 0, 0, 1, video::SColor(), txc[16], txc[19]), // front video::S3DVertex(min.X, max.Y, min.Z, 0, 0, -1, video::SColor(), txc[20], txc[21]), video::S3DVertex(max.X, max.Y, min.Z, 0, 0, -1, video::SColor(), txc[22], txc[21]), video::S3DVertex(max.X, min.Y, min.Z, 0, 0, -1, video::SColor(), txc[22], txc[23]), video::S3DVertex(min.X, min.Y, min.Z, 0, 0, -1, video::SColor(), 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}; for (s32 j = 0; j < 24; ++j) { int tileindex = MYMIN(j / 4, tilecount - 1); vertices[j].Color = encode_light_and_color(lights[light_indices[j]], tiles[tileindex].color, light_source); if (!light_source) applyFacesShading(vertices[j].Color, vertices[j].Normal); } // Add to mesh collector for (s32 k = 0; k < 6; ++k) { int tileindex = MYMIN(k, tilecount - 1); collector->append(tiles[tileindex], vertices + 4 * k, 4, indices, 6); } } // 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 - color of the cuboid // 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. // light source - if greater than zero, the box's faces will not be shaded void makeCuboid(MeshCollector *collector, const aabb3f &box, TileSpec *tiles, int tilecount, const video::SColor &c, const f32* txc, const u8 light_source) { video::SColor color[6]; for (u8 i = 0; i < 6; i++) color[i] = c; makeCuboid(collector, box, tiles, tilecount, color, txc, light_source); } // Gets the base lighting values for a node // frame - resulting (opaque) data // p - node position (absolute) // data - ... // light_source - node light emission level static void getSmoothLightFrame(LightFrame *frame, const v3s16 &p, MeshMakeData *data, u8 light_source) { for (int k = 0; k < 8; ++k) { u16 light = getSmoothLight(p, light_dirs[k], data); frame->lightsA[k] = light & 0xff; frame->lightsB[k] = light >> 8; } frame->light_source = light_source; } // Calculates vertex light level // frame - light values from getSmoothLightFrame() // vertex_pos - vertex position in the node (coordinates are clamped to [0.0, 1.0] or so) static u16 blendLight(const LightFrame &frame, const core::vector3df& 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 // frame - light values from getSmoothLightFrame() // vertex_pos - vertex position in the node (coordinates are clamped to [0.0, 1.0] or so) // tile_color - node's tile color static video::SColor blendLight(const LightFrame &frame, const core::vector3df& vertex_pos, video::SColor tile_color) { u16 light = blendLight(frame, vertex_pos); return encode_light_and_color(light, tile_color, frame.light_source); } static video::SColor blendLight(const LightFrame &frame, const core::vector3df& vertex_pos, const core::vector3df& vertex_normal, video::SColor tile_color) { video::SColor color = blendLight(frame, vertex_pos, tile_color); if (!frame.light_source) applyFacesShading(color, vertex_normal); return color; } 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; } static void makeAutoLightedCuboid(MeshCollector *collector, MeshMakeData *data, const v3f &pos, aabb3f box, TileSpec &tile, /* pre-computed, for non-smooth lighting only */ const video::SColor color, /* for smooth lighting only */ const LightFrame &frame) { 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 += pos; box.MaxEdge += pos; 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 }; if (data->m_smooth_lighting) { u16 lights[8]; for (int j = 0; j < 8; ++j) { f32 x = (j & 4) ? dx2 : dx1; f32 y = (j & 2) ? dy2 : dy1; f32 z = (j & 1) ? dz2 : dz1; lights[j] = blendLight(frame, core::vector3df(x, y, z)); } makeSmoothLightedCuboid(collector, box, &tile, 1, lights, txc, frame.light_source); } else { makeCuboid(collector, box, &tile, 1, color, txc, frame.light_source); } } static void makeAutoLightedCuboidEx(MeshCollector *collector, MeshMakeData *data, const v3f &pos, aabb3f box, TileSpec &tile, f32 *txc, /* pre-computed, for non-smooth lighting only */ const video::SColor color, /* for smooth lighting only */ const LightFrame &frame) { 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 += pos; box.MaxEdge += pos; if (data->m_smooth_lighting) { u16 lights[8]; for (int j = 0; j < 8; ++j) { f32 x = (j & 4) ? dx2 : dx1; f32 y = (j & 2) ? dy2 : dy1; f32 z = (j & 1) ? dz2 : dz1; lights[j] = blendLight(frame, core::vector3df(x, y, z)); } makeSmoothLightedCuboid(collector, box, &tile, 1, lights, txc, frame.light_source); } else { makeCuboid(collector, box, &tile, 1, color, txc, frame.light_source); } } // 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; } /*! * Returns the i-th special tile for a map node. */ static TileSpec getSpecialTile(const ContentFeatures &f, const MapNode &n, u8 i) { TileSpec copy = f.special_tiles[i]; if (!copy.has_color) n.getColor(f, &copy.color); return copy; } /* 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_client->ndef(); scene::ISceneManager* smgr = data->m_client->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") && !data->m_smooth_lighting; // Mesh cache is not supported with smooth lighting 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; if (f.drawtype == NDT_AIRLIKE) continue; LightFrame frame; if (data->m_smooth_lighting) getSmoothLightFrame(&frame, blockpos_nodes + p, data, f.light_source); else frame.light_source = f.light_source; switch(f.drawtype) { default: infostream << "Got " << f.drawtype << std::endl; FATAL_ERROR("Unknown drawtype"); break; case NDT_LIQUID: { /* Add water sources to mesh if using new style */ TileSpec tile_liquid = getSpecialTile(f, n, 0); TileSpec tile_liquid_bfculled = getNodeTile(n, p, v3s16(0,0,0), data); u16 l = getInteriorLight(n, 0, nodedef); video::SColor c1 = encode_light_and_color(l, tile_liquid.color, f.light_source); video::SColor c2 = encode_light_and_color(l, tile_liquid_bfculled.color, f.light_source); 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; /* 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; video::SColor *c = &c1; if(n_feat.solidness != 0 || n_feat.visual_solidness != 0) { current_tile = &tile_liquid_bfculled; c = &c2; } 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; }*/ if (data->m_smooth_lighting) vertices[j].Color = blendLight(frame, vertices[j].Pos, current_tile->color); 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, c1, 0,1), video::S3DVertex(BS/2,0,BS/2, 0,0,0, c1, 1,1), video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c1, 1,0), video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c1, 0,0), }; for (s32 i = 0; i < 4; i++) { vertices[i].Pos.Y += 0.5 * BS; if (data->m_smooth_lighting) vertices[i].Color = blendLight(frame, vertices[i].Pos, tile_liquid.color); vertices[i].Pos += intToFloat(p, BS); } 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 = getSpecialTile(f, n, 0); TileSpec tile_liquid_bfculled = getSpecialTile(f, n, 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 c1 = encode_light_and_color(l, tile_liquid.color, f.light_source); video::SColor c2 = encode_light_and_color(l, tile_liquid_bfculled.color, 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; video::SColor *c = &c1; if(n_feat.solidness != 0 || n_feat.visual_solidness != 0) { current_tile = &tile_liquid_bfculled; c = &c2; } 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; }*/ if (data->m_smooth_lighting) vertices[j].Color = blendLight(frame, vertices[j].Pos, current_tile->color); 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, c1, 0,1), video::S3DVertex(BS/2,0,BS/2, 0,0,0, c1, 1,1), video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c1, 1,0), video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c1, 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]; if (data->m_smooth_lighting) vertices[i].Color = blendLight(frame, vertices[i].Pos, tile_liquid.color); 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 = encode_light_and_color(l, tile.color, 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; video::SColor c2=c; if(!f.light_source) applyFacesShading(c2, v3f(dir.X, dir.Y, dir.Z)); // The face at Z+ video::S3DVertex vertices[4] = { video::S3DVertex(-BS/2,-BS/2,BS/2, dir.X,dir.Y,dir.Z, c2, 1,1), video::S3DVertex(BS/2,-BS/2,BS/2, dir.X,dir.Y,dir.Z, c2, 0,1), video::S3DVertex(BS/2,BS/2,BS/2, dir.X,dir.Y,dir.Z, c2, 0,0), video::S3DVertex(-BS/2,BS/2,BS/2, dir.X,dir.Y,dir.Z, c2, 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++) { if (data->m_smooth_lighting) vertices[i].Color = blendLight(frame, vertices[i].Pos, vertices[i].Normal, tile.color); 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) }; u16 l = getInteriorLight(n, 1, nodedef); u8 i; TileSpec tiles[6]; for (i = 0; i < 6; i++) tiles[i] = getNodeTile(n, p, dirs[i], data); video::SColor tile0color = encode_light_and_color(l, tiles[0].color, f.light_source); TileSpec glass_tiles[6]; video::SColor glasscolor[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]; } for (i = 0; i < 6; i++) glasscolor[i] = encode_light_and_color(l, glass_tiles[i].color, f.light_source); u8 param2 = n.getParam2(); bool H_merge = ! bool(param2 & 128); bool V_merge = ! bool(param2 & 64); param2 = param2 & 63; 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 }; 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]; makeAutoLightedCuboid(&collector, data, pos, box, tiles[0], tile0color, frame); } for(i = 0; i < 6; i++) { if (!visible_faces[i]) continue; box = glass_faces[i]; makeAutoLightedCuboid(&collector, data, pos, box, glass_tiles[i], glasscolor[i], frame); } 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 tile = getSpecialTile(f, n, 0); video::SColor special_color = encode_light_and_color(l, tile.color, f.light_source); 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); makeAutoLightedCuboid(&collector, data, pos, box, tile, special_color, frame); } break;} case NDT_ALLFACES: { TileSpec tile_leaves = getNodeTile(n, p, v3s16(0,0,0), data); u16 l = getInteriorLight(n, 1, nodedef); video::SColor c = encode_light_and_color(l, tile_leaves.color, f.light_source); v3f pos = intToFloat(p, BS); aabb3f box(-BS/2,-BS/2,-BS/2,BS/2,BS/2,BS/2); makeAutoLightedCuboid(&collector, data, pos, box, tile_leaves, c, frame); 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 } else { tileindex = 2; // side } TileSpec tile = getNodeTileN(n, p, tileindex, data); tile.material_flags &= ~MATERIAL_FLAG_BACKFACE_CULLING; tile.material_flags |= MATERIAL_FLAG_CRACK_OVERLAY; u16 l = getInteriorLight(n, 1, nodedef); video::SColor c = encode_light_and_color(l, tile.color, f.light_source); float s = BS/2*f.visual_scale; // Wall at X+ of node video::S3DVertex vertices[4] = { video::S3DVertex(-s,-s,0, 0,0,0, c, 0,1), video::S3DVertex( s,-s,0, 0,0,0, c, 1,1), video::S3DVertex( s, s,0, 0,0,0, c, 1,0), video::S3DVertex(-s, s,0, 0,0,0, c, 0,0), }; for (s32 i = 0; i < 4; i++) { if(dir == v3s16(1,0,0)) vertices[i].Pos.rotateXZBy(0); if(dir == v3s16(-1,0,0)) vertices[i].Pos.rotateXZBy(180); if(dir == v3s16(0,0,1)) vertices[i].Pos.rotateXZBy(90); if(dir == v3s16(0,0,-1)) vertices[i].Pos.rotateXZBy(-90); if(dir == v3s16(0,-1,0)) vertices[i].Pos.rotateXZBy(45); if(dir == v3s16(0,1,0)) vertices[i].Pos.rotateXZBy(-45); if (data->m_smooth_lighting) vertices[i].Color = blendLight(frame, vertices[i].Pos, tile.color); 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_SIGNLIKE: { TileSpec tile = getNodeTileN(n, p, 0, data); tile.material_flags &= ~MATERIAL_FLAG_BACKFACE_CULLING; tile.material_flags |= MATERIAL_FLAG_CRACK_OVERLAY; u16 l = getInteriorLight(n, 0, nodedef); video::SColor c = encode_light_and_color(l, tile.color, f.light_source); float d = (float)BS/16; float s = BS/2*f.visual_scale; // Wall at X+ of node video::S3DVertex vertices[4] = { video::S3DVertex(BS/2-d, s, s, 0,0,0, c, 0,0), video::S3DVertex(BS/2-d, s, -s, 0,0,0, c, 1,0), video::S3DVertex(BS/2-d, -s, -s, 0,0,0, c, 1,1), video::S3DVertex(BS/2-d, -s, s, 0,0,0, c, 0,1), }; v3s16 dir = n.getWallMountedDir(nodedef); for (s32 i = 0; i < 4; i++) { if(dir == v3s16(1,0,0)) vertices[i].Pos.rotateXZBy(0); if(dir == v3s16(-1,0,0)) vertices[i].Pos.rotateXZBy(180); if(dir == v3s16(0,0,1)) vertices[i].Pos.rotateXZBy(90); if(dir == v3s16(0,0,-1)) vertices[i].Pos.rotateXZBy(-90); if(dir == v3s16(0,-1,0)) vertices[i].Pos.rotateXYBy(-90); if(dir == v3s16(0,1,0)) vertices[i].Pos.rotateXYBy(90); if (data->m_smooth_lighting) vertices[i].Color = blendLight(frame, vertices[i].Pos, tile.color); 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_PLANTLIKE: { PseudoRandom rng(x<<8 | z | y<<16); TileSpec tile = getNodeTileN(n, p, 0, data); tile.material_flags |= MATERIAL_FLAG_CRACK_OVERLAY; u16 l = getInteriorLight(n, 1, nodedef); video::SColor c = encode_light_and_color(l, tile.color, f.light_source); float s = BS / 2 * f.visual_scale; // add sqrt(2) visual scale if ((f.param_type_2 == CPT2_MESHOPTIONS) && ((n.param2 & 0x10) != 0)) s *= 1.41421; float random_offset_X = .0; float random_offset_Z = .0; if ((f.param_type_2 == CPT2_MESHOPTIONS) && ((n.param2 & 0x8) != 0)) { random_offset_X = BS * ((rng.next() % 16 / 16.0) * 0.29 - 0.145); random_offset_Z = BS * ((rng.next() % 16 / 16.0) * 0.29 - 0.145); } for (int j = 0; j < 4; j++) { video::S3DVertex vertices[4] = { video::S3DVertex(-s,-BS/2, 0, 0,0,0, c, 0,1), video::S3DVertex( s,-BS/2, 0, 0,0,0, c, 1,1), video::S3DVertex( s,-BS/2 + s*2,0, 0,0,0, c, 1,0), video::S3DVertex(-s,-BS/2 + s*2,0, 0,0,0, c, 0,0), }; float rotate_degree = 0; u8 p2mesh = 0; if (f.param_type_2 == CPT2_DEGROTATE) rotate_degree = n.param2 * 2; if (f.param_type_2 != CPT2_MESHOPTIONS) { if (j == 0) { for (u16 i = 0; i < 4; i++) vertices[i].Pos.rotateXZBy(46 + rotate_degree); } else if (j == 1) { for (u16 i = 0; i < 4; i++) vertices[i].Pos.rotateXZBy(-44 + rotate_degree); } } else { p2mesh = n.param2 & 0x7; switch (p2mesh) { case 0: // x if (j == 0) { for (u16 i = 0; i < 4; i++) vertices[i].Pos.rotateXZBy(46); } else if (j == 1) { for (u16 i = 0; i < 4; i++) vertices[i].Pos.rotateXZBy(-44); } break; case 1: // + if (j == 0) { for (u16 i = 0; i < 4; i++) vertices[i].Pos.rotateXZBy(91); } else if (j == 1) { for (u16 i = 0; i < 4; i++) vertices[i].Pos.rotateXZBy(1); } break; case 2: // * if (j == 0) { for (u16 i = 0; i < 4; i++) vertices[i].Pos.rotateXZBy(121); } else if (j == 1) { for (u16 i = 0; i < 4; i++) vertices[i].Pos.rotateXZBy(241); } else { // (j == 2) for (u16 i = 0; i < 4; i++) vertices[i].Pos.rotateXZBy(1); } break; case 3: // # switch (j) { case 0: for (u16 i = 0; i < 4; i++) { vertices[i].Pos.rotateXZBy(1); vertices[i].Pos.Z += BS / 4; } break; case 1: for (u16 i = 0; i < 4; i++) { vertices[i].Pos.rotateXZBy(91); vertices[i].Pos.X += BS / 4; } break; case 2: for (u16 i = 0; i < 4; i++) { vertices[i].Pos.rotateXZBy(181); vertices[i].Pos.Z -= BS / 4; } break; case 3: for (u16 i = 0; i < 4; i++) { vertices[i].Pos.rotateXZBy(271); vertices[i].Pos.X -= BS / 4; } break; } break; case 4: // outward leaning #-like switch (j) { case 0: for (u16 i = 2; i < 4; i++) vertices[i].Pos.Z -= BS / 2; for (u16 i = 0; i < 4; i++) vertices[i].Pos.rotateXZBy(1); break; case 1: for (u16 i = 2; i < 4; i++) vertices[i].Pos.Z -= BS / 2; for (u16 i = 0; i < 4; i++) vertices[i].Pos.rotateXZBy(91); break; case 2: for (u16 i = 2; i < 4; i++) vertices[i].Pos.Z -= BS / 2; for (u16 i = 0; i < 4; i++) vertices[i].Pos.rotateXZBy(181); break; case 3: for (u16 i = 2; i < 4; i++) vertices[i].Pos.Z -= BS / 2; for (u16 i = 0; i < 4; i++) vertices[i].Pos.rotateXZBy(271); break; } break; } } for (int i = 0; i < 4; i++) { vertices[i].Pos *= f.visual_scale; vertices[i].Pos.Y += BS/2 * (f.visual_scale - 1); if (data->m_smooth_lighting) vertices[i].Color = blendLight(frame, vertices[i].Pos, tile.color); vertices[i].Pos += intToFloat(p, BS); // move to a random spot to avoid moire if ((f.param_type_2 == CPT2_MESHOPTIONS) && ((n.param2 & 0x8) != 0)) { vertices[i].Pos.X += random_offset_X; vertices[i].Pos.Z += random_offset_Z; } // randomly move each face up/down if ((f.param_type_2 == CPT2_MESHOPTIONS) && ((n.param2 & 0x20) != 0)) { PseudoRandom yrng(j | x<<16 | z<<8 | y<<24 ); vertices[i].Pos.Y -= BS * ((yrng.next() % 16 / 16.0) * 0.125); } } u16 indices[] = {0, 1, 2, 2, 3, 0}; // Add to mesh collector collector.append(tile, vertices, 4, indices, 6); // stop adding faces for meshes with less than 4 faces if (f.param_type_2 == CPT2_MESHOPTIONS) { if (((p2mesh == 0) || (p2mesh == 1)) && (j == 1)) break; else if ((p2mesh == 2) && (j == 2)) break; } else if (j == 1) { break; } } break;} case NDT_FIRELIKE: { TileSpec tile = getNodeTileN(n, p, 0, data); tile.material_flags |= MATERIAL_FLAG_CRACK_OVERLAY; u16 l = getInteriorLight(n, 1, nodedef); video::SColor c = encode_light_and_color(l, tile.color, f.light_source); float s = BS / 2 * f.visual_scale; content_t current = n.getContent(); content_t n2c; MapNode n2; v3s16 n2p; 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) }; int doDraw[6] = {0, 0, 0, 0, 0, 0}; bool drawAllFaces = true; // Check for adjacent nodes for (int i = 0; i < 6; i++) { n2p = blockpos_nodes + p + dirs[i]; n2 = data->m_vmanip.getNodeNoEx(n2p); n2c = n2.getContent(); if (n2c != CONTENT_IGNORE && n2c != CONTENT_AIR && n2c != current) { doDraw[i] = 1; if (drawAllFaces) drawAllFaces = false; } } for (int j = 0; j < 6; j++) { video::S3DVertex vertices[4] = { video::S3DVertex(-s, -BS / 2, 0, 0, 0, 0, c, 0, 1), video::S3DVertex( s, -BS / 2, 0, 0, 0, 0, c, 1, 1), video::S3DVertex( s, -BS / 2 + s * 2, 0, 0, 0, 0, c, 1, 0), video::S3DVertex(-s, -BS / 2 + s * 2, 0, 0, 0, 0, c, 0, 0), }; // Calculate which faces should be drawn, (top or sides) if (j == 0 && (drawAllFaces || (doDraw[3] == 1 || doDraw[1] == 1))) { for (int i = 0; i < 4; i++) { vertices[i].Pos.rotateXZBy(90); vertices[i].Pos.rotateXYBy(-10); vertices[i].Pos.X -= 4.0; } } else if (j == 1 && (drawAllFaces || (doDraw[5] == 1 || doDraw[1] == 1))) { for (int i = 0; i < 4; i++) { vertices[i].Pos.rotateXZBy(180); vertices[i].Pos.rotateYZBy(10); vertices[i].Pos.Z -= 4.0; } } else if (j == 2 && (drawAllFaces || (doDraw[2] == 1 || doDraw[1] == 1))) { for (int i = 0; i < 4; i++) { vertices[i].Pos.rotateXZBy(270); vertices[i].Pos.rotateXYBy(10); vertices[i].Pos.X += 4.0; } } else if (j == 3 && (drawAllFaces || (doDraw[4] == 1 || doDraw[1] == 1))) { for (int i = 0; i < 4; i++) { vertices[i].Pos.rotateYZBy(-10); vertices[i].Pos.Z += 4.0; } // Center cross-flames } else if (j == 4 && (drawAllFaces || doDraw[1] == 1)) { for (int i = 0; i < 4; i++) { vertices[i].Pos.rotateXZBy(45); } } else if (j == 5 && (drawAllFaces || doDraw[1] == 1)) { for (int i = 0; i < 4; i++) { vertices[i].Pos.rotateXZBy(-45); } // Render flames on bottom of node above } else if (j == 0 && doDraw[0] == 1 && doDraw[1] == 0) { for (int i = 0; i < 4; i++) { vertices[i].Pos.rotateYZBy(70); vertices[i].Pos.rotateXZBy(90); vertices[i].Pos.Y += 4.84; vertices[i].Pos.X -= 4.7; } } else if (j == 1 && doDraw[0] == 1 && doDraw[1] == 0) { for (int i = 0; i < 4; i++) { vertices[i].Pos.rotateYZBy(70); vertices[i].Pos.rotateXZBy(180); vertices[i].Pos.Y += 4.84; vertices[i].Pos.Z -= 4.7; } } else if (j == 2 && doDraw[0] == 1 && doDraw[1] == 0) { for (int i = 0; i < 4; i++) { vertices[i].Pos.rotateYZBy(70); vertices[i].Pos.rotateXZBy(270); vertices[i].Pos.Y += 4.84; vertices[i].Pos.X += 4.7; } } else if (j == 3 && doDraw[0] == 1 && doDraw[1] == 0) { for (int i = 0; i < 4; i++) { vertices[i].Pos.rotateYZBy(70); vertices[i].Pos.Y += 4.84; vertices[i].Pos.Z += 4.7; } } else { // Skip faces that aren't adjacent to a node continue; } for (int i = 0; i < 4; i++) { vertices[i].Pos *= f.visual_scale; if (data->m_smooth_lighting) vertices[i].Color = blendLight(frame, vertices[i].Pos, tile.color); 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_FENCELIKE: { TileSpec tile = getNodeTile(n, p, v3s16(0,0,0), data); TileSpec tile_nocrack = tile; tile_nocrack.material_flags &= ~MATERIAL_FLAG_CRACK; // Put wood the right way around in the posts TileSpec tile_rot = tile; tile_rot.rotation = 1; u16 l = getInteriorLight(n, 1, nodedef); video::SColor c = encode_light_and_color(l, tile.color, f.light_source); const f32 post_rad=(f32)BS/8; const f32 bar_rad=(f32)BS/16; const f32 bar_len=(f32)(BS/2)-post_rad; v3f pos = intToFloat(p, BS); // The post - always present aabb3f post(-post_rad,-BS/2,-post_rad,post_rad,BS/2,post_rad); f32 postuv[24]={ 6/16.,6/16.,10/16.,10/16., 6/16.,6/16.,10/16.,10/16., 0/16.,0,4/16.,1, 4/16.,0,8/16.,1, 8/16.,0,12/16.,1, 12/16.,0,16/16.,1}; makeAutoLightedCuboidEx(&collector, data, pos, post, tile_rot, postuv, c, frame); // 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) { aabb3f bar(-bar_len+BS/2,-bar_rad+BS/4,-bar_rad, bar_len+BS/2,bar_rad+BS/4,bar_rad); f32 xrailuv[24]={ 0/16.,2/16.,16/16.,4/16., 0/16.,4/16.,16/16.,6/16., 6/16.,6/16.,8/16.,8/16., 10/16.,10/16.,12/16.,12/16., 0/16.,8/16.,16/16.,10/16., 0/16.,14/16.,16/16.,16/16.}; makeAutoLightedCuboidEx(&collector, data, pos, bar, tile_nocrack, xrailuv, c, frame); bar.MinEdge.Y -= BS/2; bar.MaxEdge.Y -= BS/2; makeAutoLightedCuboidEx(&collector, data, pos, bar, tile_nocrack, xrailuv, c, frame); } // 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) { aabb3f bar(-bar_rad,-bar_rad+BS/4,-bar_len+BS/2, bar_rad,bar_rad+BS/4,bar_len+BS/2); f32 zrailuv[24]={ 3/16.,1/16.,5/16.,5/16., // cannot rotate; stretch 4/16.,1/16.,6/16.,5/16., // for wood texture instead 0/16.,9/16.,16/16.,11/16., 0/16.,6/16.,16/16.,8/16., 6/16.,6/16.,8/16.,8/16., 10/16.,10/16.,12/16.,12/16.}; makeAutoLightedCuboidEx(&collector, data, pos, bar, tile_nocrack, zrailuv, c, frame); bar.MinEdge.Y -= BS/2; bar.MaxEdge.Y -= BS/2; makeAutoLightedCuboidEx(&collector, data, pos, bar, tile_nocrack, zrailuv, c, frame); } break;} case NDT_RAILLIKE: { bool is_rail_x[6]; /* (-1,-1,0) X (1,-1,0) (-1,0,0) X (1,0,0) (-1,1,0) X (1,1,0) */ bool is_rail_z[6]; content_t thiscontent = n.getContent(); std::string groupname = "connect_to_raillike"; // name of the group that enables connecting to raillike nodes of different kind int self_group = ((ItemGroupList) nodedef->get(n).groups)[groupname]; u8 index = 0; for (s8 y0 = -1; y0 <= 1; y0++) { // Prevent from indexing never used coordinates for (s8 xz = -1; xz <= 1; xz++) { if (xz == 0) continue; MapNode n_xy = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x + xz, y + y0, z)); MapNode n_zy = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x, y + y0, z + xz)); const ContentFeatures &def_xy = nodedef->get(n_xy); const ContentFeatures &def_zy = nodedef->get(n_zy); // Check if current node would connect with the rail is_rail_x[index] = ((def_xy.drawtype == NDT_RAILLIKE && ((ItemGroupList) def_xy.groups)[groupname] == self_group) || n_xy.getContent() == thiscontent); is_rail_z[index] = ((def_zy.drawtype == NDT_RAILLIKE && ((ItemGroupList) def_zy.groups)[groupname] == self_group) || n_zy.getContent() == thiscontent); index++; } } bool is_rail_x_all[2]; // [0] = negative x, [1] = positive x coordinate from the current node position bool is_rail_z_all[2]; is_rail_x_all[0] = is_rail_x[0] || is_rail_x[2] || is_rail_x[4]; is_rail_x_all[1] = is_rail_x[1] || is_rail_x[3] || is_rail_x[5]; is_rail_z_all[0] = is_rail_z[0] || is_rail_z[2] || is_rail_z[4]; is_rail_z_all[1] = is_rail_z[1] || is_rail_z[3] || is_rail_z[5]; // reasonable default, flat straight unrotated rail bool is_straight = true; int adjacencies = 0; int angle = 0; u8 tileindex = 0; // check for sloped rail if (is_rail_x[4] || is_rail_x[5] || is_rail_z[4] || is_rail_z[5]) { adjacencies = 5; // 5 means sloped is_straight = true; // sloped is always straight } else { // is really straight, rails on both sides is_straight = (is_rail_x_all[0] && is_rail_x_all[1]) || (is_rail_z_all[0] && is_rail_z_all[1]); adjacencies = is_rail_x_all[0] + is_rail_x_all[1] + is_rail_z_all[0] + is_rail_z_all[1]; } switch (adjacencies) { case 1: if (is_rail_x_all[0] || is_rail_x_all[1]) angle = 90; break; case 2: if (!is_straight) tileindex = 1; // curved if (is_rail_x_all[0] && is_rail_x_all[1]) angle = 90; if (is_rail_z_all[0] && is_rail_z_all[1]) { if (is_rail_z[4]) angle = 180; } else if (is_rail_x_all[0] && is_rail_z_all[0]) angle = 270; else if (is_rail_x_all[0] && is_rail_z_all[1]) angle = 180; else if (is_rail_x_all[1] && is_rail_z_all[1]) angle = 90; break; case 3: // here is where the potential to 'switch' a junction is, but not implemented at present tileindex = 2; // t-junction if(!is_rail_x_all[1]) angle = 180; if(!is_rail_z_all[0]) angle = 90; if(!is_rail_z_all[1]) angle = 270; break; case 4: tileindex = 3; // crossing break; case 5: //sloped if (is_rail_z[4]) angle = 180; if (is_rail_x[4]) angle = 90; if (is_rail_x[5]) angle = -90; break; default: break; } TileSpec tile = getNodeTileN(n, p, tileindex, data); tile.material_flags &= ~MATERIAL_FLAG_BACKFACE_CULLING; tile.material_flags |= MATERIAL_FLAG_CRACK_OVERLAY; u16 l = getInteriorLight(n, 0, nodedef); video::SColor c = encode_light_and_color(l, tile.color, f.light_source); float d = (float)BS/64; float s = BS/2; short g = -1; if (is_rail_x[4] || is_rail_x[5] || is_rail_z[4] || is_rail_z[5]) g = 1; //Object is at a slope video::S3DVertex vertices[4] = { video::S3DVertex(-s, -s+d, -s, 0, 0, 0, c, 0, 1), video::S3DVertex( s, -s+d, -s, 0, 0, 0, c, 1, 1), video::S3DVertex( s, g*s+d, s, 0, 0, 0, c, 1, 0), video::S3DVertex(-s, g*s+d, s, 0, 0, 0, c, 0, 0), }; for(s32 i=0; i<4; i++) { if(angle != 0) vertices[i].Pos.rotateXZBy(angle); if (data->m_smooth_lighting) vertices[i].Color = blendLight(frame, vertices[i].Pos, tile.color); vertices[i].Pos += intToFloat(p, BS); } u16 indices[] = {0,1,2,2,3,0}; collector.append(tile, vertices, 4, indices, 6); break;} case NDT_NODEBOX: { 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) }; TileSpec tiles[6]; video::SColor colors[6]; for (int j = 0; j < 6; j++) { // Handles facedir rotation for textures tiles[j] = getNodeTile(n, p, tile_dirs[j], data); } if (!data->m_smooth_lighting) { u16 l = getInteriorLight(n, 1, nodedef); for (int j = 0; j < 6; j++) colors[j] = encode_light_and_color(l, tiles[j].color, f.light_source); } v3f pos = intToFloat(p, BS); int neighbors = 0; // locate possible neighboring nodes to connect to if (f.node_box.type == NODEBOX_CONNECTED) { v3s16 p2 = p; p2.Y++; getNeighborConnectingFace(blockpos_nodes + p2, nodedef, data, n, 1, &neighbors); p2 = p; p2.Y--; getNeighborConnectingFace(blockpos_nodes + p2, nodedef, data, n, 2, &neighbors); p2 = p; p2.Z--; getNeighborConnectingFace(blockpos_nodes + p2, nodedef, data, n, 4, &neighbors); p2 = p; p2.X--; getNeighborConnectingFace(blockpos_nodes + p2, nodedef, data, n, 8, &neighbors); p2 = p; p2.Z++; getNeighborConnectingFace(blockpos_nodes + p2, nodedef, data, n, 16, &neighbors); p2 = p; p2.X++; getNeighborConnectingFace(blockpos_nodes + p2, nodedef, data, n, 32, &neighbors); } std::vector<aabb3f> boxes; n.getNodeBoxes(nodedef, &boxes, neighbors); for (std::vector<aabb3f>::iterator i = boxes.begin(); i != boxes.end(); ++i) { aabb3f box = *i; 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 += pos; box.MaxEdge += pos; if (box.MinEdge.X > box.MaxEdge.X) std::swap(box.MinEdge.X, box.MaxEdge.X); if (box.MinEdge.Y > box.MaxEdge.Y) std::swap(box.MinEdge.Y, box.MaxEdge.Y); if (box.MinEdge.Z > box.MaxEdge.Z) std::swap(box.MinEdge.Z, box.MaxEdge.Z); // // Compute texture 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] = { // up tx1, 1-tz2, tx2, 1-tz1, // down tx1, tz1, tx2, tz2, // right tz1, 1-ty2, tz2, 1-ty1, // left 1-tz2, 1-ty2, 1-tz1, 1-ty1, // back 1-tx2, 1-ty2, 1-tx1, 1-ty1, // front tx1, 1-ty2, tx2, 1-ty1, }; if (data->m_smooth_lighting) { u16 lights[8]; for (int j = 0; j < 8; ++j) { f32 x = (j & 4) ? dx2 : dx1; f32 y = (j & 2) ? dy2 : dy1; f32 z = (j & 1) ? dz2 : dz1; lights[j] = blendLight(frame, core::vector3df(x, y, z)); } makeSmoothLightedCuboid(&collector, box, tiles, 6, lights, txc, f.light_source); } else { makeCuboid(&collector, box, tiles, 6, colors, txc, f.light_source); } } break;} case NDT_MESH: { v3f pos = intToFloat(p, BS); u16 l = getInteriorLight(n, 1, nodedef); u8 facedir = 0; 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 for (u16 j = 0; j < f.mesh_ptr[0]->getMeshBufferCount(); j++) { const TileSpec &tile = getNodeTileN(n, p, j, data); scene::IMeshBuffer *buf = f.mesh_ptr[facedir]->getMeshBuffer(j); collector.append(tile, (video::S3DVertex *) buf->getVertices(), buf->getVertexCount(), buf->getIndices(), buf->getIndexCount(), pos, encode_light_and_color(l, tile.color, f.light_source), f.light_source); } } else if (f.mesh_ptr[0]) { // no cache, clone and rotate mesh scene::IMesh* mesh = cloneMesh(f.mesh_ptr[0]); rotateMeshBy6dFacedir(mesh, facedir); recalculateBoundingBox(mesh); meshmanip->recalculateNormals(mesh, true, false); for (u16 j = 0; j < mesh->getMeshBufferCount(); j++) { const TileSpec &tile = getNodeTileN(n, p, j, data); scene::IMeshBuffer *buf = mesh->getMeshBuffer(j); video::S3DVertex *vertices = (video::S3DVertex *)buf->getVertices(); u32 vertex_count = buf->getVertexCount(); if (data->m_smooth_lighting) { for (u16 m = 0; m < vertex_count; ++m) { video::S3DVertex &vertex = vertices[m]; vertex.Color = blendLight(frame, vertex.Pos, vertex.Normal, tile.color); vertex.Pos += pos; } collector.append(tile, vertices, vertex_count, buf->getIndices(), buf->getIndexCount()); } else { collector.append(tile, vertices, vertex_count, buf->getIndices(), buf->getIndexCount(), pos, encode_light_and_color(l, tile.color, f.light_source), f.light_source); } } mesh->drop(); } break;} } } }