void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
{
- if (protocol_version < 30) {
+ if (protocol_version < 31) {
serializeOld(os, protocol_version);
return;
}
// version
- writeU8(os, 9);
+ writeU8(os, 10);
// general
os << serializeString(name);
writeU8(os, 6);
for (u32 i = 0; i < 6; i++)
tiledef[i].serialize(os, protocol_version);
+ for (u32 i = 0; i < 6; i++)
+ tiledef_overlay[i].serialize(os, protocol_version);
writeU8(os, CF_SPECIAL_COUNT);
for (u32 i = 0; i < CF_SPECIAL_COUNT; i++) {
tiledef_special[i].serialize(os, protocol_version);
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 > 9) {
+ } else if (version > 10) {
throw SerializationError("unsupported ContentFeatures version");
}
throw SerializationError("unsupported tile count");
for (u32 i = 0; i < 6; i++)
tiledef[i].deSerialize(is, version, drawtype);
+ if (version >= 10)
+ for (u32 i = 0; i < 6; i++)
+ tiledef_overlay[i].deSerialize(is, version, drawtype);
if (readU8(is) != CF_SPECIAL_COUNT)
throw SerializationError("unsupported CF_SPECIAL_COUNT");
for (u32 i = 0; i < CF_SPECIAL_COUNT; i++)
}
#ifndef SERVER
-void ContentFeatures::fillTileAttribs(ITextureSource *tsrc, TileSpec *tile,
+void ContentFeatures::fillTileAttribs(ITextureSource *tsrc, TileLayer *tile,
TileDef *tiledef, u32 shader_id, bool use_normal_texture,
bool backface_culling, u8 material_type)
{
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;
- bool is_water_surface = false;
u8 material_type = (alpha == 255) ?
TILE_MATERIAL_BASIC : TILE_MATERIAL_ALPHA;
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;
for (u32 i = 0; i < 6; i++)
tdef[i].name += std::string("^[noalpha");
}
- if (waving == 1)
+ if (waving >= 1)
material_type = TILE_MATERIAL_WAVING_LEAVES;
break;
case NDT_PLANTLIKE:
solidness = 0;
- if (waving == 1)
+ if (waving >= 1)
material_type = TILE_MATERIAL_WAVING_PLANTS;
break;
case NDT_FIRELIKE:
solidness = 0;
break;
case NDT_MESH:
+ case NDT_NODEBOX:
solidness = 0;
+ if (waving == 1)
+ material_type = TILE_MATERIAL_WAVING_PLANTS;
+ else if (waving == 2)
+ material_type = TILE_MATERIAL_WAVING_LEAVES;
break;
case NDT_TORCHLIKE:
case NDT_SIGNLIKE:
case NDT_FENCELIKE:
case NDT_RAILLIKE:
- case NDT_NODEBOX:
solidness = 0;
break;
}
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;
- if (name == "default:water_source")
- is_water_surface = true;
}
- // Vertex alpha is no longer supported, correct if necessary.
- correctAlpha();
-
u32 tile_shader[6];
for (u16 j = 0; j < 6; j++) {
tile_shader[j] = shdsrc->getShader("nodes_shader",
material_type, drawtype);
}
- if (is_water_surface) {
- tile_shader[0] = shdsrc->getShader("water_surface_shader",
- material_type, drawtype);
- }
-
// Tiles (fill in f->tiles[])
for (u16 j = 0; j < 6; j++) {
- fillTileAttribs(tsrc, &tiles[j], &tdef[j], tile_shader[j],
+ fillTileAttribs(tsrc, &tiles[j].layers[0], &tdef[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],
+ tile_shader[j], tsettings.use_normal_texture,
+ tdef[j].backface_culling, material_type);
}
// Special tiles (fill in f->special_tiles[])
for (u16 j = 0; j < CF_SPECIAL_COUNT; j++) {
- fillTileAttribs(tsrc, &special_tiles[j], &tiledef_special[j],
+ fillTileAttribs(tsrc, &special_tiles[j].layers[0], &tdef_spec[j],
tile_shader[j], tsettings.use_normal_texture,
- tiledef_special[j].backface_culling, material_type);
+ tdef_spec[j].backface_culling, material_type);
}
+ if (param_type_2 == CPT2_COLOR ||
+ param_type_2 == CPT2_COLORED_FACEDIR ||
+ param_type_2 == CPT2_COLORED_WALLMOUNTED)
+ palette = tsrc->getPalette(palette_name);
+
if ((drawtype == NDT_MESH) && (mesh != "")) {
// Meshnode drawtype
// Read the mesh and apply scale
virtual void removeNode(const std::string &name);
virtual void updateAliases(IItemDefManager *idef);
virtual void applyTextureOverrides(const std::string &override_filepath);
- //! Returns a palette or NULL if not found. Only on client.
- std::vector<video::SColor> *getPalette(const ContentFeatures &f,
- const IGameDef *gamedef);
virtual void updateTextures(IGameDef *gamedef,
void (*progress_cbk)(void *progress_args, u32 progress, u32 max_progress),
void *progress_cbk_args);
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);
// Next possibly free id
content_t m_next_id;
- // Maps image file names to loaded palettes.
- UNORDERED_MAP<std::string, std::vector<video::SColor> > m_palettes;
-
// NodeResolvers to callback once node registration has ended
std::vector<NodeResolver *> m_pending_resolve_callbacks;
// Erase node content from all groups it belongs to
for (UNORDERED_MAP<std::string, GroupItems>::iterator iter_groups =
- m_group_to_items.begin();
- iter_groups != m_group_to_items.end();) {
+ m_group_to_items.begin(); iter_groups != m_group_to_items.end();) {
GroupItems &items = iter_groups->second;
for (GroupItems::iterator iter_groupitems = items.begin();
iter_groupitems != items.end();) {
if (iter_groupitems->first == id)
items.erase(iter_groupitems++);
else
- iter_groupitems++;
+ ++iter_groupitems;
}
// Check if group is empty
if (items.size() == 0)
m_group_to_items.erase(iter_groups++);
else
- iter_groups++;
+ ++iter_groups;
}
}
}
}
-std::vector<video::SColor> *CNodeDefManager::getPalette(
- const ContentFeatures &f, const IGameDef *gamedef)
-{
-#ifndef SERVER
- // This works because colors always use the most significant bits
- // of param2. If you add a new colored type which uses param2
- // in a more advanced way, you should change this code, too.
- u32 palette_pixels = 0;
- switch (f.param_type_2) {
- case CPT2_COLOR:
- palette_pixels = 256;
- break;
- case CPT2_COLORED_FACEDIR:
- palette_pixels = 8;
- break;
- case CPT2_COLORED_WALLMOUNTED:
- palette_pixels = 32;
- break;
- default:
- return NULL;
- }
- // This many param2 values will have the same color
- u32 step = 256 / palette_pixels;
- const std::string &name = f.palette_name;
- if (name == "")
- return NULL;
- Client *client = (Client *) gamedef;
- ITextureSource *tsrc = client->tsrc();
-
- UNORDERED_MAP<std::string, std::vector<video::SColor> >::iterator it =
- m_palettes.find(name);
- if (it == m_palettes.end()) {
- // Create palette
- if (!tsrc->isKnownSourceImage(name)) {
- warningstream << "CNodeDefManager::getPalette(): palette \"" << name
- << "\" could not be loaded." << std::endl;
- return NULL;
- }
- video::IImage *img = tsrc->generateImage(name);
- std::vector<video::SColor> new_palette;
- u32 w = img->getDimension().Width;
- u32 h = img->getDimension().Height;
- // Real area of the image
- u32 area = h * w;
- if (area != palette_pixels)
- warningstream << "CNodeDefManager::getPalette(): the "
- << "specified palette image \"" << name << "\" does not "
- << "contain exactly " << palette_pixels
- << " pixels." << std::endl;
- if (area > palette_pixels)
- area = palette_pixels;
- // For each pixel in the image
- for (u32 i = 0; i < area; i++) {
- video::SColor c = img->getPixel(i % w, i / w);
- // Fill in palette with 'step' colors
- for (u32 j = 0; j < step; j++)
- new_palette.push_back(c);
- }
- img->drop();
- // Fill in remaining elements
- while (new_palette.size() < 256)
- new_palette.push_back(video::SColor(0xFFFFFFFF));
- m_palettes[name] = new_palette;
- it = m_palettes.find(name);
- }
- if (it != m_palettes.end())
- return &((*it).second);
-
-#endif
- return NULL;
-}
-
void CNodeDefManager::updateTextures(IGameDef *gamedef,
void (*progress_callback)(void *progress_args, u32 progress, u32 max_progress),
void *progress_callback_args)
TextureSettings tsettings;
tsettings.readSettings();
- m_palettes.clear();
u32 size = m_content_features.size();
for (u32 i = 0; i < size; i++) {
ContentFeatures *f = &(m_content_features[i]);
- f->palette = getPalette(*f, gamedef);
f->updateTextures(tsrc, shdsrc, meshmanip, client, tsettings);
progress_callback(progress_callback_args, i, size);
}
if (protocol_version < 30 && drawtype == NDT_PLANTLIKE)
compatible_visual_scale = sqrt(visual_scale);
+ TileDef compatible_tiles[6];
+ for (u8 i = 0; i < 6; i++) {
+ compatible_tiles[i] = tiledef[i];
+ if (tiledef_overlay[i].name != "") {
+ std::stringstream s;
+ s << "(" << tiledef[i].name << ")^(" << tiledef_overlay[i].name
+ << ")";
+ compatible_tiles[i].name = s.str();
+ }
+ }
+
// Protocol >= 24
- if (protocol_version < 30) {
+ if (protocol_version < 31) {
writeU8(os, protocol_version < 27 ? 7 : 8);
os << serializeString(name);
writeF1000(os, compatible_visual_scale);
writeU8(os, 6);
for (u32 i = 0; i < 6; i++)
- tiledef[i].serialize(os, protocol_version);
+ compatible_tiles[i].serialize(os, protocol_version);
writeU8(os, CF_SPECIAL_COUNT);
for (u32 i = 0; i < CF_SPECIAL_COUNT; i++)
tiledef_special[i].serialize(os, protocol_version);
}
}
-
-inline bool CNodeDefManager::getNodeRegistrationStatus() const
-{
- return m_node_registration_complete;
-}
-
-
inline void CNodeDefManager::setNodeRegistrationStatus(bool completed)
{
m_node_registration_complete = completed;