#include "itemdef.h"
#ifndef SERVER
-#include "client/tile.h"
#include "mesh.h"
+#include "shader.h"
#include "client.h"
+#include "client/renderingengine.h"
+#include "client/tile.h"
#include <IMeshManipulator.h>
#endif
#include "log.h"
*/
static void serializeSimpleSoundSpec(const SimpleSoundSpec &ss,
- std::ostream &os)
+ std::ostream &os, u8 version)
{
os<<serializeString(ss.name);
writeF1000(os, ss.gain);
+
+ if (version >= 11)
+ writeF1000(os, ss.pitch);
}
-static void deSerializeSimpleSoundSpec(SimpleSoundSpec &ss, std::istream &is)
+static void deSerializeSimpleSoundSpec(SimpleSoundSpec &ss, std::istream &is, u8 version)
{
ss.name = deSerializeString(is);
ss.gain = readF1000(is);
+
+ if (version >= 11)
+ ss.pitch = readF1000(is);
}
void TextureSettings::readSettings()
}
// version
- writeU8(os, 10);
+ u8 version = (protocol_version >= 34) ? 11 : 10;
+ writeU8(os, version);
// general
os << serializeString(name);
collision_box.serialize(os, protocol_version);
// sound
- serializeSimpleSoundSpec(sound_footstep, os);
- serializeSimpleSoundSpec(sound_dig, os);
- serializeSimpleSoundSpec(sound_dug, os);
+ serializeSimpleSoundSpec(sound_footstep, os, version);
+ serializeSimpleSoundSpec(sound_dig, os, version);
+ serializeSimpleSoundSpec(sound_dug, os, version);
// legacy
writeU8(os, legacy_facedir_simple);
writeU8(os, legacy_wallmounted);
}
-void ContentFeatures::correctAlpha()
+void ContentFeatures::correctAlpha(TileDef *tiles, int length)
{
+ // alpha == 0 means that the node is using texture alpha
if (alpha == 0 || alpha == 255)
return;
- for (u32 i = 0; i < 6; i++) {
- std::stringstream s;
- s << tiledef[i].name << "^[noalpha^[opacity:" << ((int)alpha);
- tiledef[i].name = s.str();
- }
-
- for (u32 i = 0; i < CF_SPECIAL_COUNT; i++) {
+ for (int i = 0; i < length; i++) {
+ if (tiles[i].name == "")
+ continue;
std::stringstream s;
- s << tiledef_special[i].name << "^[noalpha^[opacity:" << ((int)alpha);
- tiledef_special[i].name = s.str();
+ s << tiles[i].name << "^[noalpha^[opacity:" << ((int)alpha);
+ tiles[i].name = s.str();
}
}
if (version < 9) {
deSerializeOld(is, version);
return;
- } else if (version > 10) {
+ } else if (version > 11) {
throw SerializationError("unsupported ContentFeatures version");
}
collision_box.deSerialize(is);
// sounds
- deSerializeSimpleSoundSpec(sound_footstep, is);
- deSerializeSimpleSoundSpec(sound_dig, is);
- deSerializeSimpleSoundSpec(sound_dug, is);
+ deSerializeSimpleSoundSpec(sound_footstep, is, version);
+ deSerializeSimpleSoundSpec(sound_dig, is, version);
+ deSerializeSimpleSoundSpec(sound_dug, is, version);
// read legacy properties
legacy_facedir_simple = readU8(is);
tile->material_flags &= ~MATERIAL_FLAG_ANIMATION;
} else {
std::ostringstream os(std::ios::binary);
- tile->frames.resize(frame_count);
+ if (!tile->frames) {
+ tile->frames = std::make_shared<std::vector<FrameSpec>>();
+ }
+ tile->frames->resize(frame_count);
for (int i = 0; i < frame_count; i++) {
if (tile->normal_texture)
frame.normal_texture = tsrc->getNormalTexture(os.str());
frame.flags_texture = tile->flags_texture;
- tile->frames[i] = frame;
+ (*tile->frames)[i] = frame;
}
}
}
if (tdef[j].name == "")
tdef[j].name = "unknown_node.png";
}
+ // also the overlay tiles
+ TileDef tdef_overlay[6];
+ for (u32 j = 0; j < 6; j++)
+ tdef_overlay[j] = tiledef_overlay[j];
+ // also the special tiles
+ TileDef tdef_spec[6];
+ for (u32 j = 0; j < CF_SPECIAL_COUNT; j++)
+ tdef_spec[j] = tiledef_special[j];
bool is_liquid = false;
switch (drawtype) {
default:
case NDT_NORMAL:
+ material_type = (alpha == 255) ?
+ TILE_MATERIAL_OPAQUE : TILE_MATERIAL_ALPHA;
solidness = 2;
break;
case NDT_AIRLIKE:
visual_solidness = 1;
} else if (tsettings.leaves_style == LEAVES_SIMPLE) {
for (u32 j = 0; j < 6; j++) {
- if (tiledef_special[j].name != "")
- tdef[j].name = tiledef_special[j].name;
+ if (tdef_spec[j].name != "")
+ tdef[j].name = tdef_spec[j].name;
}
drawtype = NDT_GLASSLIKE;
solidness = 0;
case NDT_RAILLIKE:
solidness = 0;
break;
+ case NDT_PLANTLIKE_ROOTED:
+ solidness = 2;
+ break;
}
- if (is_liquid)
+ if (is_liquid) {
+ // Vertex alpha is no longer supported, correct if necessary.
+ correctAlpha(tdef, 6);
+ correctAlpha(tdef_overlay, 6);
+ correctAlpha(tdef_spec, CF_SPECIAL_COUNT);
material_type = (alpha == 255) ?
TILE_MATERIAL_LIQUID_OPAQUE : TILE_MATERIAL_LIQUID_TRANSPARENT;
+ }
- // Vertex alpha is no longer supported, correct if necessary.
- correctAlpha();
+ u32 tile_shader = shdsrc->getShader("nodes_shader", material_type, drawtype);
- u32 tile_shader[6];
- for (u16 j = 0; j < 6; j++) {
- tile_shader[j] = shdsrc->getShader("nodes_shader",
- material_type, drawtype);
- }
+ u8 overlay_material = material_type;
+ if (overlay_material == TILE_MATERIAL_OPAQUE)
+ overlay_material = TILE_MATERIAL_BASIC;
+ else if (overlay_material == TILE_MATERIAL_LIQUID_OPAQUE)
+ overlay_material = TILE_MATERIAL_LIQUID_TRANSPARENT;
+
+ u32 overlay_shader = shdsrc->getShader("nodes_shader", overlay_material, drawtype);
// Tiles (fill in f->tiles[])
for (u16 j = 0; j < 6; j++) {
- fillTileAttribs(tsrc, &tiles[j].layers[0], &tdef[j], tile_shader[j],
+ fillTileAttribs(tsrc, &tiles[j].layers[0], &tdef[j], tile_shader,
tsettings.use_normal_texture,
- tiledef[j].backface_culling, material_type);
- if (tiledef_overlay[j].name!="")
- fillTileAttribs(tsrc, &tiles[j].layers[1], &tiledef_overlay[j],
- tile_shader[j], tsettings.use_normal_texture,
- tiledef[j].backface_culling, material_type);
+ tdef[j].backface_culling, material_type);
+ if (tdef_overlay[j].name != "")
+ fillTileAttribs(tsrc, &tiles[j].layers[1], &tdef_overlay[j],
+ overlay_shader, tsettings.use_normal_texture,
+ tdef[j].backface_culling, overlay_material);
+ }
+
+ u8 special_material = material_type;
+ if (drawtype == NDT_PLANTLIKE_ROOTED) {
+ if (waving == 1)
+ special_material = TILE_MATERIAL_WAVING_PLANTS;
+ else if (waving == 2)
+ special_material = TILE_MATERIAL_WAVING_LEAVES;
}
+ u32 special_shader = shdsrc->getShader("nodes_shader", special_material, drawtype);
// Special tiles (fill in f->special_tiles[])
for (u16 j = 0; j < CF_SPECIAL_COUNT; j++) {
- fillTileAttribs(tsrc, &special_tiles[j].layers[0], &tiledef_special[j],
- tile_shader[j], tsettings.use_normal_texture,
- tiledef_special[j].backface_culling, material_type);
+ fillTileAttribs(tsrc, &special_tiles[j].layers[0], &tdef_spec[j],
+ special_shader, tsettings.use_normal_texture,
+ tdef_spec[j].backface_culling, special_material);
}
if (param_type_2 == CPT2_COLOR ||
void serialize(std::ostream &os, u16 protocol_version) const;
void deSerialize(std::istream &is);
- inline virtual bool getNodeRegistrationStatus() const;
inline virtual void setNodeRegistrationStatus(bool completed);
virtual void pendNodeResolve(NodeResolver *nr);
// item aliases too. Updated by updateAliases()
// Note: Not serialized.
- UNORDERED_MAP<std::string, content_t> m_name_id_mapping_with_aliases;
+ std::unordered_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.
- UNORDERED_MAP<std::string, GroupItems> m_group_to_items;
+ std::unordered_map<std::string, GroupItems> m_group_to_items;
// Next possibly free id
content_t m_next_id;
bool CNodeDefManager::getId(const std::string &name, content_t &result) const
{
- UNORDERED_MAP<std::string, content_t>::const_iterator
+ std::unordered_map<std::string, content_t>::const_iterator
i = m_name_id_mapping_with_aliases.find(name);
if(i == m_name_id_mapping_with_aliases.end())
return false;
}
std::string group = name.substr(6);
- UNORDERED_MAP<std::string, GroupItems>::const_iterator
+ std::unordered_map<std::string, GroupItems>::const_iterator
i = m_group_to_items.find(group);
if (i == m_group_to_items.end())
return true;
i != def.groups.end(); ++i) {
std::string group_name = i->first;
- UNORDERED_MAP<std::string, GroupItems>::iterator
+ std::unordered_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(
}
// Erase node content from all groups it belongs to
- for (UNORDERED_MAP<std::string, GroupItems>::iterator iter_groups =
+ for (std::unordered_map<std::string, GroupItems>::iterator iter_groups =
m_group_to_items.begin(); iter_groups != m_group_to_items.end();) {
GroupItems &items = iter_groups->second;
for (GroupItems::iterator iter_groupitems = items.begin();
Client *client = (Client *)gamedef;
ITextureSource *tsrc = client->tsrc();
IShaderSource *shdsrc = client->getShaderSource();
- scene::ISceneManager* smgr = client->getSceneManager();
- scene::IMeshManipulator* meshmanip = smgr->getMeshManipulator();
+ scene::IMeshManipulator *meshmanip =
+ RenderingEngine::get_scene_manager()->getMeshManipulator();
TextureSettings tsettings;
tsettings.readSettings();
selection_box.serialize(os, protocol_version);
writeU8(os, legacy_facedir_simple);
writeU8(os, legacy_wallmounted);
- serializeSimpleSoundSpec(sound_footstep, os);
- serializeSimpleSoundSpec(sound_dig, os);
- serializeSimpleSoundSpec(sound_dug, os);
+ serializeSimpleSoundSpec(sound_footstep, os, 10);
+ serializeSimpleSoundSpec(sound_dig, os, 10);
+ serializeSimpleSoundSpec(sound_dug, os, 10);
writeU8(os, rightclickable);
writeU8(os, drowning);
writeU8(os, leveled);
selection_box.deSerialize(is);
legacy_facedir_simple = readU8(is);
legacy_wallmounted = readU8(is);
- deSerializeSimpleSoundSpec(sound_footstep, is);
- deSerializeSimpleSoundSpec(sound_dig, is);
- deSerializeSimpleSoundSpec(sound_dug, is);
+ deSerializeSimpleSoundSpec(sound_footstep, is, version);
+ deSerializeSimpleSoundSpec(sound_dig, is, version);
+ deSerializeSimpleSoundSpec(sound_dug, is, version);
} else if (version == 6) {
name = deSerializeString(is);
groups.clear();
selection_box.deSerialize(is);
legacy_facedir_simple = readU8(is);
legacy_wallmounted = readU8(is);
- deSerializeSimpleSoundSpec(sound_footstep, is);
- deSerializeSimpleSoundSpec(sound_dig, is);
- deSerializeSimpleSoundSpec(sound_dug, is);
+ deSerializeSimpleSoundSpec(sound_footstep, is, version);
+ deSerializeSimpleSoundSpec(sound_dig, is, version);
+ deSerializeSimpleSoundSpec(sound_dug, is, version);
rightclickable = readU8(is);
drowning = readU8(is);
leveled = readU8(is);
selection_box.deSerialize(is);
legacy_facedir_simple = readU8(is);
legacy_wallmounted = readU8(is);
- deSerializeSimpleSoundSpec(sound_footstep, is);
- deSerializeSimpleSoundSpec(sound_dig, is);
- deSerializeSimpleSoundSpec(sound_dug, is);
+ deSerializeSimpleSoundSpec(sound_footstep, is, version);
+ deSerializeSimpleSoundSpec(sound_dig, is, version);
+ deSerializeSimpleSoundSpec(sound_dug, is, version);
rightclickable = readU8(is);
drowning = readU8(is);
leveled = readU8(is);
}
}
-
-inline bool CNodeDefManager::getNodeRegistrationStatus() const
-{
- return m_node_registration_complete;
-}
-
-
inline void CNodeDefManager::setNodeRegistrationStatus(bool completed)
{
m_node_registration_complete = completed;
NodeResolver::NodeResolver()
{
- m_ndef = NULL;
- m_nodenames_idx = 0;
- m_nnlistsizes_idx = 0;
- m_resolve_done = false;
-
m_nodenames.reserve(16);
m_nnlistsizes.reserve(4);
}