/*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 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
#include "settings.h"
#include "nameidmapping.h"
#include "util/serialize.h"
+//#include "profiler.h" // For TimeTaker
/*
NodeBox
writeU8(os, 1); // version
writeU8(os, type);
- if(type == NODEBOX_FIXED)
+ if(type == NODEBOX_FIXED || type == NODEBOX_LEVELED)
{
writeU16(os, fixed.size());
for(std::vector<aabb3f>::const_iterator
type = (enum NodeBoxType)readU8(is);
- if(type == NODEBOX_FIXED)
+ if(type == NODEBOX_FIXED || type == NODEBOX_LEVELED)
{
u16 fixed_count = readU16(is);
while(fixed_count--)
/*
TileDef
*/
-
-void TileDef::serialize(std::ostream &os) const
+
+void TileDef::serialize(std::ostream &os, u16 protocol_version) const
{
- writeU8(os, 0); // version
+ if(protocol_version >= 17)
+ writeU8(os, 1);
+ else
+ writeU8(os, 0);
os<<serializeString(name);
writeU8(os, animation.type);
writeU16(os, animation.aspect_w);
writeU16(os, animation.aspect_h);
writeF1000(os, animation.length);
+ if(protocol_version >= 17)
+ writeU8(os, backface_culling);
}
void TileDef::deSerialize(std::istream &is)
{
int version = readU8(is);
- if(version != 0)
- throw SerializationError("unsupported TileDef version");
name = deSerializeString(is);
animation.type = (TileAnimationType)readU8(is);
animation.aspect_w = readU16(is);
animation.aspect_h = readU16(is);
animation.length = readF1000(is);
+ if(version >= 1)
+ backface_culling = readU8(is);
}
/*
has_after_destruct = false;
/*
Actual data
-
+
NOTE: Most of this is always overridden by the default values given
in builtin.lua
*/
diggable = true;
climbable = false;
buildable_to = false;
+ rightclickable = true;
+ leveled = 0;
liquid_type = LIQUID_NONE;
liquid_alternative_flowing = "";
liquid_alternative_source = "";
liquid_viscosity = 0;
liquid_renewable = true;
+ drowning = true;
light_source = 0;
damage_per_second = 0;
node_box = NodeBox();
writeF1000(os, visual_scale);
writeU8(os, 6);
for(u32 i=0; i<6; i++)
- tiledef[i].serialize(os);
+ tiledef[i].serialize(os, protocol_version);
writeU8(os, CF_SPECIAL_COUNT);
for(u32 i=0; i<CF_SPECIAL_COUNT; i++){
- tiledef_special[i].serialize(os);
+ tiledef_special[i].serialize(os, protocol_version);
}
writeU8(os, alpha);
writeU8(os, post_effect_color.getAlpha());
serializeSimpleSoundSpec(sound_footstep, os);
serializeSimpleSoundSpec(sound_dig, os);
serializeSimpleSoundSpec(sound_dug, os);
+ writeU8(os, rightclickable);
// Stuff below should be moved to correct place in a version that otherwise changes
// the protocol version
+ writeU8(os, drowning);
+ writeU8(os, leveled);
}
void ContentFeatures::deSerialize(std::istream &is)
deSerializeSimpleSoundSpec(sound_footstep, is);
deSerializeSimpleSoundSpec(sound_dig, is);
deSerializeSimpleSoundSpec(sound_dug, is);
+ rightclickable = readU8(is);
// If you add anything here, insert it primarily inside the try-catch
// block to not need to increase the version.
try{
// Stuff below should be moved to correct place in a version that
// otherwise changes the protocol version
+ drowning = readU8(is);
+ leveled = readU8(is);
}catch(SerializationError &e) {};
}
ContentFeatures &f = m_content_features[i];
f.reset(); // Reset to defaults
}
-
+
// Set CONTENT_AIR
{
ContentFeatures f;
virtual void getIds(const std::string &name, std::set<content_t> &result)
const
{
+ //TimeTaker t("getIds", NULL, PRECISION_MICRO);
if(name.substr(0,6) != "group:"){
content_t id = CONTENT_IGNORE;
if(getId(name, id))
return;
}
std::string group = name.substr(6);
+
+#if 1 // Optimized version, takes less than 1 microsecond at -O1
+ std::map<std::string, GroupItems>::const_iterator
+ i = m_group_to_items.find(group);
+ if (i == m_group_to_items.end())
+ return;
+
+ const GroupItems &items = i->second;
+ for (GroupItems::const_iterator j = items.begin();
+ j != items.end(); ++j) {
+ if ((*j).second != 0)
+ result.insert((*j).first);
+ }
+#else // Old version, takes about ~150-200us at -O1
for(u16 id=0; id<=MAX_CONTENT; id++)
{
const ContentFeatures &f = m_content_features[id];
if(itemgroup_get(f.groups, group) != 0)
result.insert(id);
}
+#endif
+ //printf("getIds: %dus\n", t.stop());
}
virtual const ContentFeatures& get(const std::string &name) const
{
m_content_features[c] = def;
if(def.name != "")
addNameIdMapping(c, def.name);
+
+ // Add this content to the list of all groups it belongs to
+ for (ItemGroupList::const_iterator i = def.groups.begin();
+ i != def.groups.end(); ++i) {
+ std::string group_name = i->first;
+
+ std::map<std::string, GroupItems>::iterator
+ j = m_group_to_items.find(group_name);
+ if (j == m_group_to_items.end()) {
+ m_group_to_items[group_name].push_back(std::make_pair(c, i->second));
+ } else {
+ GroupItems &items = j->second;
+ items.push_back(std::make_pair(c, i->second));
+ }
+ }
}
virtual content_t set(const std::string &name,
const ContentFeatures &def)
bool new_style_water = g_settings->getBool("new_style_water");
bool new_style_leaves = g_settings->getBool("new_style_leaves");
bool opaque_water = g_settings->getBool("opaque_water");
-
+
for(u16 i=0; i<=MAX_CONTENT; i++)
{
ContentFeatures *f = &m_content_features[i];
-
+
// Figure out the actual tiles to use
TileDef tiledef[6];
for(u32 j=0; j<6; j++)
{
tiledef[j] = f->tiledef[j];
if(tiledef[j].name == "")
- tiledef[j].name = "unknown_block.png";
+ tiledef[j].name = "unknown_node.png";
}
bool is_liquid = false;
f->solidness = 0;
f->visual_solidness = 1;
break;
+ case NDT_GLASSLIKE_FRAMED:
+ f->solidness = 0;
+ f->visual_solidness = 1;
+ break;
case NDT_ALLFACES:
f->solidness = 0;
f->visual_solidness = 1;
}
}
break;
+ case NDT_PLANTLIKE:
+ f->solidness = 0;
+ f->backface_culling = false;
+ break;
case NDT_TORCHLIKE:
case NDT_SIGNLIKE:
- case NDT_PLANTLIKE:
case NDT_FENCELIKE:
case NDT_RAILLIKE:
case NDT_NODEBOX:
break;
}
- u8 material_type = 0;
- if(is_liquid){
- if(f->alpha == 255)
- material_type = TILE_MATERIAL_LIQUID_OPAQUE;
- else
- material_type = TILE_MATERIAL_LIQUID_TRANSPARENT;
- } else{
- material_type = TILE_MATERIAL_BASIC;
- }
+ u8 material_type;
+ if (is_liquid)
+ material_type = (f->alpha == 255) ? TILE_MATERIAL_LIQUID_OPAQUE : TILE_MATERIAL_LIQUID_TRANSPARENT;
+ else
+ material_type = (f->alpha == 255) ? TILE_MATERIAL_BASIC : TILE_MATERIAL_ALPHA;
// Tiles (fill in f->tiles[])
for(u16 j=0; j<6; j++){
// Texture
- f->tiles[j].texture = tsrc->getTexture(tiledef[j].name);
+ f->tiles[j].texture = tsrc->getTexture(
+ tiledef[j].name,
+ &f->tiles[j].texture_id);
// Alpha
f->tiles[j].alpha = f->alpha;
// Material type
if(f->tiles[j].material_flags &
MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES)
{
- // Get raw texture size to determine frame count by
+ // Get texture size to determine frame count by
// aspect ratio
- video::ITexture *t = tsrc->getTextureRaw(tiledef[j].name);
- v2u32 size = t->getOriginalSize();
+ v2u32 size = f->tiles[j].texture->getOriginalSize();
int frame_height = (float)size.X /
(float)tiledef[j].animation.aspect_w *
(float)tiledef[j].animation.aspect_h;
// Special tiles (fill in f->special_tiles[])
for(u16 j=0; j<CF_SPECIAL_COUNT; j++){
// Texture
- f->special_tiles[j].texture =
- tsrc->getTexture(f->tiledef_special[j].name);
+ f->special_tiles[j].texture = tsrc->getTexture(
+ f->tiledef_special[j].name,
+ &f->special_tiles[j].texture_id);
// Alpha
f->special_tiles[j].alpha = f->alpha;
// Material type
if(f->special_tiles[j].material_flags &
MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES)
{
- // Get raw texture size to determine frame count by
+ // Get texture size to determine frame count by
// aspect ratio
- video::ITexture *t = tsrc->getTextureRaw(f->tiledef_special[j].name);
- v2u32 size = t->getOriginalSize();
+ v2u32 size = f->special_tiles[j].texture->getOriginalSize();
int frame_height = (float)size.X /
(float)f->tiledef_special[j].animation.aspect_w *
(float)f->tiledef_special[j].animation.aspect_h;
// item aliases too. Updated by updateAliases()
// Note: Not serialized.
std::map<std::string, content_t> m_name_id_mapping_with_aliases;
+ // A mapping from groups to a list of content_ts (and their levels)
+ // that belong to it. Necessary for a direct lookup in getIds().
+ // Note: Not serialized.
+ std::map<std::string, GroupItems> m_group_to_items;
};
IWritableNodeDefManager* createNodeDefManager()
writeF1000(os, visual_scale);
writeU8(os, 6);
for(u32 i=0; i<6; i++)
- tiledef[i].serialize(os);
+ tiledef[i].serialize(os, protocol_version);
writeU8(os, CF_SPECIAL_COUNT);
for(u32 i=0; i<CF_SPECIAL_COUNT; i++){
- tiledef_special[i].serialize(os);
+ tiledef_special[i].serialize(os, protocol_version);
}
writeU8(os, alpha);
writeU8(os, post_effect_color.getAlpha());
projects / minetest.git / blobdiff