This simplifies NodeResolver logic and makes some interfaces cleaner.
* `options` is a table containing the following optional parameters:
* If `use_comments` is true and `format` is "lua", the Lua code generated will have (X, Z)
* position comments for every X row generated in the schematic data for easier reading.
- * If `register_after_load` is true, then `schematic`, if not yet loaded, will be registered
- * after loading and persist in memory.
- * node_resolve_method can be one of either "none", "direct", or "deferred" (default: "none")
- * This sets the way method by with node names are mapped to their content IDs, if loaded:
- * "none" performs no node resolution and preserves all node names from the schematic definition
- * "direct" performs an immediate lookup of content ID, given all the nodes that have been
- * registered up to this point in script execution
- * "deferred" pends node resolution until after the script registration phase has ended
- * In practice, it is recommended to use "none" in nearly all use cases.
### Misc.
* `minetest.get_connected_players()`: returns list of `ObjectRefs`
b->m_nodenames.push_back("mapgen_water_source");
b->m_nodenames.push_back("mapgen_river_water_source");
b->m_nodenames.push_back("air");
- m_ndef->pendNodeResolve(b, NODE_RESOLVE_DEFERRED);
+ m_ndef->pendNodeResolve(b);
add(b);
}
bool force_placement = (flags & DECO_FORCE_PLACEMENT);
- schematic->blitToVManip(p, vm, rot, force_placement, m_ndef);
+ schematic->blitToVManip(p, vm, rot, force_placement);
return 1;
}
}
-void Schematic::blitToVManip(v3s16 p, MMVManip *vm, Rotation rot,
- bool force_placement, INodeDefManager *ndef)
+void Schematic::blitToVManip(v3s16 p, MMVManip *vm,
+ Rotation rot, bool force_placement)
{
+ sanity_check(m_ndef != NULL);
+
int xstride = 1;
int ystride = size.X;
int zstride = size.X * size.Y;
vm->m_data[vi].param1 = 0;
if (rot)
- vm->m_data[vi].rotateAlongYAxis(ndef, rot);
+ vm->m_data[vi].rotateAlongYAxis(m_ndef, rot);
}
}
y_map++;
}
-void Schematic::placeStructure(Map *map, v3s16 p, u32 flags, Rotation rot,
- bool force_placement, INodeDefManager *ndef)
+void Schematic::placeStructure(Map *map, v3s16 p, u32 flags,
+ Rotation rot, bool force_placement)
{
assert(schemdata != NULL); // Pre-condition
+ sanity_check(m_ndef != NULL);
+
MMVManip *vm = new MMVManip(map);
if (rot == ROTATE_RAND)
v3s16 bp2 = getNodeBlockPos(p + s - v3s16(1,1,1));
vm->initialEmerge(bp1, bp2);
- blitToVManip(p, vm, rot, force_placement, ndef);
+ blitToVManip(p, vm, rot, force_placement);
std::map<v3s16, MapBlock *> lighting_modified_blocks;
std::map<v3s16, MapBlock *> modified_blocks;
}
-bool Schematic::deserializeFromMts(std::istream *is, std::vector<std::string> *names)
+bool Schematic::deserializeFromMts(std::istream *is,
+ std::vector<std::string> *names)
{
std::istream &ss = *is;
content_t cignore = CONTENT_IGNORE;
}
-bool Schematic::serializeToMts(std::ostream *os)
+bool Schematic::serializeToMts(std::ostream *os,
+ const std::vector<std::string> &names)
{
std::ostream &ss = *os;
for (int y = 0; y != size.Y; y++) // Y slice probabilities
writeU8(ss, slice_probs[y]);
- std::vector<content_t> usednodes;
- int nodecount = size.X * size.Y * size.Z;
- build_nnlist_and_update_ids(schemdata, nodecount, &usednodes);
-
- u16 numids = usednodes.size();
- writeU16(ss, numids); // name count
- for (int i = 0; i != numids; i++)
- ss << serializeString(getNodeName(usednodes[i])); // node names
+ writeU16(ss, names.size()); // name count
+ for (size_t i = 0; i != names.size(); i++)
+ ss << serializeString(names[i]); // node names
// compressed bulk node data
MapNode::serializeBulk(ss, SER_FMT_VER_HIGHEST_WRITE,
- schemdata, nodecount, 2, 2, true);
+ schemdata, size.X * size.Y * size.Z, 2, 2, true);
return true;
}
-bool Schematic::serializeToLua(std::ostream *os, bool use_comments)
+bool Schematic::serializeToLua(std::ostream *os,
+ const std::vector<std::string> &names, bool use_comments)
{
std::ostream &ss = *os;
for (u16 x = 0; x != size.X; x++, i++) {
ss << "\t\t{"
- << "name=\"" << getNodeName(schemdata[i].getContent())
+ << "name=\"" << names[schemdata[i].getContent()]
<< "\", param1=" << (u16)schemdata[i].param1
<< ", param2=" << (u16)schemdata[i].param2
<< "}," << std::endl;
bool Schematic::loadSchematicFromFile(const std::string &filename,
- INodeDefManager *ndef, StringMap *replace_names,
- NodeResolveMethod resolve_method)
+ INodeDefManager *ndef, StringMap *replace_names)
{
std::ifstream is(filename.c_str(), std::ios_base::binary);
if (!is.good()) {
m_nnlistsizes.push_back(m_nodenames.size() - origsize);
- ndef->pendNodeResolve(this, resolve_method);
+ if (ndef)
+ ndef->pendNodeResolve(this);
return true;
}
bool Schematic::saveSchematicToFile(const std::string &filename)
{
+ MapNode *orig_schemdata = schemdata;
+ std::vector<std::string> ndef_nodenames;
+ std::vector<std::string> *names;
+
+ // Only carry out the modification if we know the nodes
+ // were resolved at this point
+ if (m_resolve_done) {
+ names = &ndef_nodenames;
+
+ u32 volume = size.X * size.Y * size.Z;
+ schemdata = new MapNode[volume];
+ for (u32 i = 0; i != volume; i++)
+ schemdata[i] = orig_schemdata[i];
+
+ generate_nodelist_and_update_ids(schemdata, volume, names, m_ndef);
+ } else { // otherwise, use the names we have on hand in the list
+ names = &m_nodenames;
+ }
+
std::ostringstream os(std::ios_base::binary);
- serializeToMts(&os);
+ serializeToMts(&os, *names);
+
+ if (m_resolve_done) {
+ delete []schemdata;
+ schemdata = orig_schemdata;
+ }
+
return fs::safeWriteToFile(filename, os.str());
}
}
-void build_nnlist_and_update_ids(MapNode *nodes, u32 nodecount,
- std::vector<content_t> *usednodes)
+void generate_nodelist_and_update_ids(MapNode *nodes, size_t nodecount,
+ std::vector<std::string> *usednodes, INodeDefManager *ndef)
{
std::map<content_t, content_t> nodeidmap;
content_t numids = 0;
- for (u32 i = 0; i != nodecount; i++) {
+ for (size_t i = 0; i != nodecount; i++) {
content_t id;
content_t c = nodes[i].getContent();
id = numids;
numids++;
- usednodes->push_back(c);
+ usednodes->push_back(ndef->get(c).name);
nodeidmap.insert(std::make_pair(c, id));
} else {
id = it->second;
void updateContentIds();
void blitToVManip(v3s16 p, MMVManip *vm,
- Rotation rot, bool force_placement, INodeDefManager *ndef);
+ Rotation rot, bool force_placement);
bool loadSchematicFromFile(const std::string &filename, INodeDefManager *ndef,
- StringMap *replace_names, NodeResolveMethod resolve_method);
+ StringMap *replace_names);
bool saveSchematicToFile(const std::string &filename);
bool getSchematicFromMap(Map *map, v3s16 p1, v3s16 p2);
- bool deserializeFromMts(std::istream *is, std::vector<std::string> *names_out);
- bool serializeToMts(std::ostream *os);
- bool serializeToLua(std::ostream *os, bool use_comments);
-
+ bool deserializeFromMts(std::istream *is, std::vector<std::string> *names);
+ bool serializeToMts(std::ostream *os, const std::vector<std::string> &names);
+ bool serializeToLua(std::ostream *os, const std::vector<std::string> &names,
+ bool use_comments);
void placeStructure(Map *map, v3s16 p, u32 flags,
- Rotation rot, bool force_placement, INodeDefManager *nef);
+ Rotation rot, bool force_placement);
void applyProbabilities(v3s16 p0,
std::vector<std::pair<v3s16, u8> > *plist,
std::vector<std::pair<s16, u8> > *splist);
IGameDef *m_gamedef;
};
-void build_nnlist_and_update_ids(MapNode *nodes, u32 nodecount,
- std::vector<content_t> *usednodes);
-
+void generate_nodelist_and_update_ids(MapNode *nodes, size_t nodecount,
+ std::vector<std::string> *usednodes, INodeDefManager *ndef);
#endif
inline virtual bool getNodeRegistrationStatus() const;
inline virtual void setNodeRegistrationStatus(bool completed);
- virtual void pendNodeResolve(NodeResolver *nr, NodeResolveMethod how);
+ virtual void pendNodeResolve(NodeResolver *nr);
virtual bool cancelNodeResolveCallback(NodeResolver *nr);
virtual void runNodeResolveCallbacks();
virtual void resetNodeResolveState();
}
-void CNodeDefManager::pendNodeResolve(NodeResolver *nr, NodeResolveMethod how)
+void CNodeDefManager::pendNodeResolve(NodeResolver *nr)
{
nr->m_ndef = this;
-
- switch (how) {
- case NODE_RESOLVE_NONE:
- break;
- case NODE_RESOLVE_DIRECT:
+ if (m_node_registration_complete)
nr->nodeResolveInternal();
- break;
- case NODE_RESOLVE_DEFERRED:
- if (m_node_registration_complete)
- nr->nodeResolveInternal();
- else
- m_pending_resolve_callbacks.push_back(nr);
- break;
- }
+ else
+ m_pending_resolve_callbacks.push_back(nr);
}
}
-const std::string &NodeResolver::getNodeName(content_t c) const
-{
- if (c < m_nodenames.size())
- return m_nodenames[c];
-
- if (m_ndef)
- return m_ndef->get(c).name;
-
- static const std::string unknown_str("unknown");
- return unknown_str;
-}
-
-
bool NodeResolver::getIdFromNrBacklog(content_t *result_out,
const std::string &node_alt, content_t c_fallback)
{
}
};
-enum NodeResolveMethod {
- NODE_RESOLVE_NONE,
- NODE_RESOLVE_DIRECT,
- NODE_RESOLVE_DEFERRED,
-};
-
class INodeDefManager {
public:
INodeDefManager(){}
virtual bool getNodeRegistrationStatus() const=0;
- virtual void pendNodeResolve(NodeResolver *nr, NodeResolveMethod how)=0;
+ virtual void pendNodeResolve(NodeResolver *nr)=0;
virtual bool cancelNodeResolveCallback(NodeResolver *nr)=0;
};
virtual bool getNodeRegistrationStatus() const=0;
virtual void setNodeRegistrationStatus(bool completed)=0;
- virtual void pendNodeResolve(NodeResolver *nr, NodeResolveMethod how)=0;
+ virtual void pendNodeResolve(NodeResolver *nr)=0;
virtual bool cancelNodeResolveCallback(NodeResolver *nr)=0;
virtual void runNodeResolveCallbacks()=0;
virtual void resetNodeResolveState()=0;
const std::string &node_alt, content_t c_fallback);
bool getIdsFromNrBacklog(std::vector<content_t> *result_out,
bool all_required=false, content_t c_fallback=CONTENT_IGNORE);
- const std::string &getNodeName(content_t c) const;
void nodeResolveInternal();
{0, NULL},
};
-struct EnumString ModApiMapgen::es_NodeResolveMethod[] =
-{
- {NODE_RESOLVE_NONE, "none"},
- {NODE_RESOLVE_DIRECT, "direct"},
- {NODE_RESOLVE_DEFERRED, "deferred"},
- {0, NULL},
-};
-
ObjDef *get_objdef(lua_State *L, int index, ObjDefManager *objmgr);
Biome *get_or_load_biome(lua_State *L, int index,
BiomeManager *biomemgr, std::set<u8> *biome_id_list);
Schematic *get_or_load_schematic(lua_State *L, int index,
- SchematicManager *schemmgr, StringMap *replace_names,
- bool register_on_load=true,
- NodeResolveMethod resolve_method=NODE_RESOLVE_DEFERRED);
+ SchematicManager *schemmgr, StringMap *replace_names);
Schematic *load_schematic(lua_State *L, int index, INodeDefManager *ndef,
- StringMap *replace_names, NodeResolveMethod resolve_method);
+ StringMap *replace_names);
Schematic *load_schematic_from_def(lua_State *L, int index,
- INodeDefManager *ndef, StringMap *replace_names,
- NodeResolveMethod resolve_method);
+ INodeDefManager *ndef, StringMap *replace_names);
bool read_schematic_def(lua_State *L, int index,
Schematic *schem, std::vector<std::string> *names);
///////////////////////////////////////////////////////////////////////////////
Schematic *get_or_load_schematic(lua_State *L, int index,
- SchematicManager *schemmgr, StringMap *replace_names,
- bool register_on_load,
- NodeResolveMethod resolve_method)
+ SchematicManager *schemmgr, StringMap *replace_names)
{
if (index < 0)
index = lua_gettop(L) + 1 + index;
return schem;
schem = load_schematic(L, index, schemmgr->getNodeDef(),
- replace_names, resolve_method);
+ replace_names);
if (!schem)
return NULL;
- if (!register_on_load)
- return schem;
-
if (schemmgr->add(schem) == OBJDEF_INVALID_HANDLE) {
delete schem;
return NULL;
Schematic *load_schematic(lua_State *L, int index, INodeDefManager *ndef,
- StringMap *replace_names, NodeResolveMethod resolve_method)
+ StringMap *replace_names)
{
if (index < 0)
index = lua_gettop(L) + 1 + index;
if (lua_istable(L, index)) {
schem = load_schematic_from_def(L, index, ndef,
- replace_names, resolve_method);
+ replace_names);
if (!schem) {
delete schem;
return NULL;
filepath = ModApiBase::getCurrentModPath(L) + DIR_DELIM + filepath;
if (!schem->loadSchematicFromFile(filepath, ndef,
- replace_names, resolve_method)) {
+ replace_names)) {
delete schem;
return NULL;
}
}
-Schematic *load_schematic_from_def(lua_State *L, int index, INodeDefManager *ndef,
- StringMap *replace_names, NodeResolveMethod resolve_method)
+Schematic *load_schematic_from_def(lua_State *L, int index,
+ INodeDefManager *ndef, StringMap *replace_names)
{
Schematic *schem = SchematicManager::create(SCHEMATIC_NORMAL);
}
}
- ndef->pendNodeResolve(schem, resolve_method);
+ ndef->pendNodeResolve(schem);
return schem;
}
nn.push_back(getstringfield_default(L, index, "node_water", ""));
nn.push_back(getstringfield_default(L, index, "node_river_water", ""));
nn.push_back(getstringfield_default(L, index, "node_dust", ""));
- ndef->pendNodeResolve(b, NODE_RESOLVE_DEFERRED);
+ ndef->pendNodeResolve(b);
return b;
}
return 0;
}
- ndef->pendNodeResolve(deco, NODE_RESOLVE_DEFERRED);
+ ndef->pendNodeResolve(deco);
ObjDefHandle handle = decomgr->add(deco);
if (handle == OBJDEF_INVALID_HANDLE) {
size_t nnames = getstringlistfield(L, index, "wherein", &ore->m_nodenames);
ore->m_nnlistsizes.push_back(nnames);
- ndef->pendNodeResolve(ore, NODE_RESOLVE_DEFERRED);
+ ndef->pendNodeResolve(ore);
lua_pushinteger(L, handle);
return 1;
read_schematic_replacements(L, 2, &replace_names);
Schematic *schem = load_schematic(L, 1, schemmgr->getNodeDef(),
- &replace_names, NODE_RESOLVE_DEFERRED);
+ &replace_names);
if (!schem)
return 0;
return 0;
}
- schem->placeStructure(map, p, 0, (Rotation)rot, force_placement,
- schemmgr->getNodeDef());
+ schem->placeStructure(map, p, 0, (Rotation)rot, force_placement);
lua_pushboolean(L, true);
return 1;
SchematicManager *schemmgr = getServer(L)->getEmergeManager()->schemmgr;
//// Read options
- NodeResolveMethod resolve_method = (NodeResolveMethod)getenumfield(L, 3,
- "node_resolve_method", es_NodeResolveMethod, NODE_RESOLVE_NONE);
- bool register_on_load = getboolfield_default(L, 3, "register_on_load", false);
bool use_comments = getboolfield_default(L, 3, "use_lua_comments", false);
- //// Read schematic
- Schematic *schem = get_or_load_schematic(L, 1, schemmgr, NULL,
- register_on_load, resolve_method);
+ //// Get schematic
+ bool was_loaded = false;
+ Schematic *schem = (Schematic *)get_objdef(L, 1, schemmgr);
+ if (!schem) {
+ schem = load_schematic(L, 1, NULL, NULL);
+ was_loaded = true;
+ }
if (!schem) {
errorstream << "serialize_schematic: failed to get schematic" << std::endl;
return 0;
std::ostringstream os(std::ios_base::binary);
switch (schem_format) {
case SCHEM_FMT_MTS:
- schem->serializeToMts(&os);
+ schem->serializeToMts(&os, schem->m_nodenames);
break;
case SCHEM_FMT_LUA:
- schem->serializeToLua(&os, use_comments);
+ schem->serializeToLua(&os, schem->m_nodenames, use_comments);
break;
default:
return 0;
}
+ if (was_loaded)
+ delete schem;
+
std::string ser = os.str();
lua_pushlstring(L, ser.c_str(), ser.length());
return 1;
ndef->resetNodeResolveState();
TEST(testPendingResolveCancellation, ndef);
-
- ndef->resetNodeResolveState();
- TEST(testDirectResolveMethod, ndef);
-
- ndef->resetNodeResolveState();
- TEST(testNoneResolveMethod, ndef);
}
class Foobar : public NodeResolver {
foobar.m_nodenames.push_back("default:desert_stone");
foobar.m_nodenames.push_back("default:shnitzle");
- ndef->pendNodeResolve(&foobar, NODE_RESOLVE_DEFERRED);
+ ndef->pendNodeResolve(&foobar);
UASSERT(foobar.m_ndef == ndef);
ndef->setNodeRegistrationStatus(true);
foobaz1.test_content2 = 5678;
foobaz1.m_nodenames.push_back("default:dirt_with_grass");
foobaz1.m_nodenames.push_back("default:abloobloobloo");
- ndef->pendNodeResolve(&foobaz1, NODE_RESOLVE_DEFERRED);
+ ndef->pendNodeResolve(&foobaz1);
Foobaz foobaz2;
foobaz2.test_content1 = 1234;
foobaz2.test_content2 = 5678;
foobaz2.m_nodenames.push_back("default:dirt_with_grass");
foobaz2.m_nodenames.push_back("default:abloobloobloo");
- ndef->pendNodeResolve(&foobaz2, NODE_RESOLVE_DEFERRED);
+ ndef->pendNodeResolve(&foobaz2);
ndef->cancelNodeResolveCallback(&foobaz1);
UASSERT(foobaz2.test_content1 == t_CONTENT_GRASS);
UASSERT(foobaz2.test_content2 == CONTENT_IGNORE);
}
-
-
-void TestNodeResolver::testDirectResolveMethod(IWritableNodeDefManager *ndef)
-{
- Foobaz foobaz;
-
- foobaz.m_nodenames.push_back("default:dirt_with_grass");
- foobaz.m_nodenames.push_back("default:abloobloobloo");
-
- UASSERTEQ(std::string, foobaz.getNodeName(1), "default:abloobloobloo");
-
- ndef->pendNodeResolve(&foobaz, NODE_RESOLVE_DIRECT);
-
- UASSERTEQ(content_t, foobaz.test_content1, t_CONTENT_GRASS);
- UASSERTEQ(content_t, foobaz.test_content2, CONTENT_IGNORE);
-
- // We expect this to be *different* because the resolution of this node had
- // failed. The internal nodename buffer is cleared and lookups should now
- // use the nodedef manager.
- UASSERT(foobaz.getNodeName(1) != "default:abloobloobloo");
-}
-
-
-void TestNodeResolver::testNoneResolveMethod(IWritableNodeDefManager *ndef)
-{
- Foobaz foobaz;
-
- foobaz.m_nodenames.push_back("default:dirt_with_grass");
- foobaz.m_nodenames.push_back("default:abloobloobloo");
-
- ndef->pendNodeResolve(&foobaz, NODE_RESOLVE_NONE);
-
- UASSERTEQ(std::string, foobaz.getNodeName(1), "default:abloobloobloo");
-}
projects / oweals / minetest.git / commitdiff