-- 'inventory_image'.
-- "item" is similar to "wielditem" but ignores the 'wield_image' parameter.
- visual_size = {x = 1, y = 1},
- -- `x` multiplies horizontal (X and Z) visual size.
- -- `y` multiplies vertical (Y) visual size.
+ visual_size = {x = 1, y = 1, z = 1},
+ -- Multipliers for the visual size. If `z` is not specified, `x` will be used
+ -- to scale the entity along both horizontal axes.
mesh = "model",
void GenericCAO::processInitData(const std::string &data)
{
std::istringstream is(data, std::ios::binary);
- int num_messages = 0;
- // version
- u8 version = readU8(is);
- // check version
- if (version == 1) { // In PROTOCOL_VERSION 14
- m_name = deSerializeString(is);
- m_is_player = readU8(is);
- m_id = readU16(is);
- m_position = readV3F1000(is);
- m_rotation = readV3F1000(is);
- m_hp = readS16(is);
- num_messages = readU8(is);
- } else {
- errorstream<<"GenericCAO: Unsupported init data version"
- <<std::endl;
+ const u8 version = readU8(is);
+
+ if (version < 1) {
+ errorstream << "GenericCAO: Unsupported init data version"
+ << std::endl;
return;
}
+ // PROTOCOL_VERSION >= 37
+ m_name = deSerializeString(is);
+ m_is_player = readU8(is);
+ m_id = readU16(is);
+ m_position = readV3F32(is);
+ m_rotation = readV3F32(is);
+ m_hp = readS16(is);
+ const u8 num_messages = readU8(is);
+
for (int i = 0; i < num_messages; i++) {
std::string message = deSerializeLongString(is);
processMessage(message);
m_spritenode->setMaterialFlag(video::EMF_FOG_ENABLE, true);
u8 li = m_last_light;
m_spritenode->setColor(video::SColor(255,li,li,li));
- m_spritenode->setSize(m_prop.visual_size*BS);
+ m_spritenode->setSize(v2f(m_prop.visual_size.X,
+ m_prop.visual_size.Y) * BS);
{
const float txs = 1.0 / 1;
const float tys = 1.0 / 1;
m_meshnode->grab();
mesh->drop();
- m_meshnode->setScale(v3f(m_prop.visual_size.X,
- m_prop.visual_size.Y,
- m_prop.visual_size.X));
+ m_meshnode->setScale(m_prop.visual_size);
u8 li = m_last_light;
setMeshColor(m_meshnode->getMesh(), video::SColor(255,li,li,li));
m_animated_meshnode->grab();
mesh->drop(); // The scene node took hold of it
m_animated_meshnode->animateJoints(); // Needed for some animations
- m_animated_meshnode->setScale(v3f(m_prop.visual_size.X,
- m_prop.visual_size.Y,
- m_prop.visual_size.X));
+ m_animated_meshnode->setScale(m_prop.visual_size);
u8 li = m_last_light;
// set vertex colors to ensure alpha is set
m_wield_meshnode->setItem(item, m_client,
(m_prop.visual == "wielditem"));
- m_wield_meshnode->setScale(
- v3f(m_prop.visual_size.X / 2, m_prop.visual_size.Y / 2,
- m_prop.visual_size.X / 2));
+ m_wield_meshnode->setScale(m_prop.visual_size / 2.0f);
u8 li = m_last_light;
m_wield_meshnode->setColor(video::SColor(255, li, li, li));
} else {
} else if (cmd == GENERIC_CMD_SET_SPRITE) {
v2s16 p = readV2S16(is);
int num_frames = readU16(is);
- float framelength = readF1000(is);
+ float framelength = readF32(is);
bool select_horiz_by_yawpitch = readU8(is);
m_tx_basepos = p;
updateTexturePos();
} else if (cmd == GENERIC_CMD_SET_PHYSICS_OVERRIDE) {
- float override_speed = readF1000(is);
- float override_jump = readF1000(is);
- float override_gravity = readF1000(is);
+ float override_speed = readF32(is);
+ float override_jump = readF32(is);
+ float override_gravity = readF32(is);
// these are sent inverted so we get true when the server sends nothing
bool sneak = !readU8(is);
bool sneak_glitch = !readU8(is);
}
} else if (cmd == GENERIC_CMD_SET_ANIMATION) {
// TODO: change frames send as v2s32 value
- v2f range = readV2F1000(is);
+ v2f range = readV2F32(is);
if (!m_is_local_player) {
m_animation_range = v2s32((s32)range.X, (s32)range.Y);
- m_animation_speed = readF1000(is);
- m_animation_blend = readF1000(is);
+ m_animation_speed = readF32(is);
+ m_animation_blend = readF32(is);
// these are sent inverted so we get true when the server sends nothing
m_animation_loop = !readU8(is);
updateAnimation();
if(player->last_animation == NO_ANIM)
{
m_animation_range = v2s32((s32)range.X, (s32)range.Y);
- m_animation_speed = readF1000(is);
- m_animation_blend = readF1000(is);
+ m_animation_speed = readF32(is);
+ m_animation_blend = readF32(is);
// these are sent inverted so we get true when the server sends nothing
m_animation_loop = !readU8(is);
}
}
}
} else if (cmd == GENERIC_CMD_SET_ANIMATION_SPEED) {
- m_animation_speed = readF1000(is);
+ m_animation_speed = readF32(is);
updateAnimationSpeed();
} else if (cmd == GENERIC_CMD_SET_BONE_POSITION) {
std::string bone = deSerializeString(is);
- v3f position = readV3F1000(is);
- v3f rotation = readV3F1000(is);
+ v3f position = readV3F32(is);
+ v3f rotation = readV3F32(is);
m_bone_position[bone] = core::vector2d<v3f>(position, rotation);
updateBonePosition();
}
m_attachment_bone = deSerializeString(is);
- m_attachment_position = readV3F1000(is);
- m_attachment_rotation = readV3F1000(is);
+ m_attachment_position = readV3F32(is);
+ m_attachment_rotation = readV3F32(is);
// localplayer itself can't be attached to localplayer
if (!m_is_local_player) {
// As there is no definition, make a smoke puff
ClientSimpleObject *simple = createSmokePuff(
m_smgr, m_env, m_position,
- m_prop.visual_size * BS);
+ v2f(m_prop.visual_size.X, m_prop.visual_size.Y) * BS);
m_env->addSimpleObject(simple);
} else if (m_reset_textures_timer < 0) {
// TODO: Execute defined fast response
// As there is no definition, make a smoke puff
ClientSimpleObject *simple = createSmokePuff(
m_smgr, m_env, m_position,
- m_prop.visual_size * BS);
+ v2f(m_prop.visual_size.X, m_prop.visual_size.Y) * BS);
m_env->addSimpleObject(simple);
}
// TODO: Execute defined fast response
os << serializeString(""); // name
writeU8(os, 0); // is_player
writeS16(os, getId()); //id
- writeV3F1000(os, m_base_position);
- writeV3F1000(os, m_rotation);
+ writeV3F32(os, m_base_position);
+ writeV3F32(os, m_rotation);
writeS16(os, m_hp);
std::ostringstream msg_os(std::ios::binary);
m_prop.pointable = true;
// Start of default appearance, this should be overwritten by Lua
m_prop.visual = "upright_sprite";
- m_prop.visual_size = v2f(1, 2);
+ m_prop.visual_size = v3f(1, 2, 1);
m_prop.textures.clear();
m_prop.textures.emplace_back("player.png");
m_prop.textures.emplace_back("player_back.png");
os << serializeString(m_player->getName()); // name
writeU8(os, 1); // is_player
writeS16(os, getId()); // id
- writeV3F1000(os, m_base_position);
- writeV3F1000(os, m_rotation);
+ writeV3F32(os, m_base_position);
+ writeV3F32(os, m_rotation);
writeS16(os, getHP());
std::ostringstream msg_os(std::ios::binary);
// parameters
writeV2S16(os, p);
writeU16(os, num_frames);
- writeF1000(os, framelength);
+ writeF32(os, framelength);
writeU8(os, select_horiz_by_yawpitch);
return os.str();
}
// command
writeU8(os, GENERIC_CMD_SET_PHYSICS_OVERRIDE);
// parameters
- writeF1000(os, physics_override_speed);
- writeF1000(os, physics_override_jump);
- writeF1000(os, physics_override_gravity);
+ writeF32(os, physics_override_speed);
+ writeF32(os, physics_override_jump);
+ writeF32(os, physics_override_gravity);
// these are sent inverted so we get true when the server sends nothing
writeU8(os, !sneak);
writeU8(os, !sneak_glitch);
// command
writeU8(os, GENERIC_CMD_SET_ANIMATION);
// parameters
- writeV2F1000(os, frames);
- writeF1000(os, frame_speed);
- writeF1000(os, frame_blend);
+ writeV2F32(os, frames);
+ writeF32(os, frame_speed);
+ writeF32(os, frame_blend);
// these are sent inverted so we get true when the server sends nothing
writeU8(os, !frame_loop);
return os.str();
// command
writeU8(os, GENERIC_CMD_SET_ANIMATION_SPEED);
// parameters
- writeF1000(os, frame_speed);
+ writeF32(os, frame_speed);
return os.str();
}
writeU8(os, GENERIC_CMD_SET_BONE_POSITION);
// parameters
os<<serializeString(bone);
- writeV3F1000(os, position);
- writeV3F1000(os, rotation);
+ writeV3F32(os, position);
+ writeV3F32(os, rotation);
return os.str();
}
// parameters
writeS16(os, parent_id);
os<<serializeString(bone);
- writeV3F1000(os, position);
- writeV3F1000(os, rotation);
+ writeV3F32(os, position);
+ writeV3F32(os, rotation);
return os.str();
}
void ItemDefinition::serialize(std::ostream &os, u16 protocol_version) const
{
- // protocol_version >= 36
- u8 version = 5;
+ // protocol_version >= 37
+ u8 version = 6;
writeU8(os, version);
writeU8(os, type);
os << serializeString(name);
os << serializeString(description);
os << serializeString(inventory_image);
os << serializeString(wield_image);
- writeV3F1000(os, wield_scale);
+ writeV3F32(os, wield_scale);
writeS16(os, stack_max);
writeU8(os, usable);
writeU8(os, liquids_pointable);
+
std::string tool_capabilities_s;
- if(tool_capabilities){
+ if (tool_capabilities) {
std::ostringstream tmp_os(std::ios::binary);
tool_capabilities->serialize(tmp_os, protocol_version);
tool_capabilities_s = tmp_os.str();
}
os << serializeString(tool_capabilities_s);
+
writeU16(os, groups.size());
for (const auto &group : groups) {
os << serializeString(group.first);
writeS16(os, group.second);
}
+
os << serializeString(node_placement_prediction);
- os << serializeString(sound_place.name);
- writeF1000(os, sound_place.gain);
- writeF1000(os, range);
- os << serializeString(sound_place_failed.name);
- writeF1000(os, sound_place_failed.gain);
+
+ // Version from ContentFeatures::serialize to keep in sync
+ sound_place.serialize(os, CONTENTFEATURES_VERSION);
+ sound_place_failed.serialize(os, CONTENTFEATURES_VERSION);
+
+ writeF32(os, range);
os << serializeString(palette_image);
writeARGB8(os, color);
-
- writeF1000(os, sound_place.pitch);
- writeF1000(os, sound_place_failed.pitch);
os << serializeString(inventory_overlay);
os << serializeString(wield_overlay);
}
// Deserialize
int version = readU8(is);
- if (version < 5)
+ if (version < 6)
throw SerializationError("unsupported ItemDefinition version");
type = (enum ItemType)readU8(is);
description = deSerializeString(is);
inventory_image = deSerializeString(is);
wield_image = deSerializeString(is);
- wield_scale = readV3F1000(is);
+ wield_scale = readV3F32(is);
stack_max = readS16(is);
usable = readU8(is);
liquids_pointable = readU8(is);
+
std::string tool_capabilities_s = deSerializeString(is);
- if(!tool_capabilities_s.empty())
- {
+ if (!tool_capabilities_s.empty()) {
std::istringstream tmp_is(tool_capabilities_s, std::ios::binary);
tool_capabilities = new ToolCapabilities;
tool_capabilities->deSerialize(tmp_is);
}
+
groups.clear();
u32 groups_size = readU16(is);
for(u32 i=0; i<groups_size; i++){
}
node_placement_prediction = deSerializeString(is);
- //deserializeSimpleSoundSpec(sound_place, is);
- sound_place.name = deSerializeString(is);
- sound_place.gain = readF1000(is);
- range = readF1000(is);
- sound_place_failed.name = deSerializeString(is);
- sound_place_failed.gain = readF1000(is);
+ // Version from ContentFeatures::serialize to keep in sync
+ sound_place.deSerialize(is, CONTENTFEATURES_VERSION);
+ sound_place_failed.deSerialize(is, CONTENTFEATURES_VERSION);
+
+ range = readF32(is);
palette_image = deSerializeString(is);
color = readARGB8(is);
-
- sound_place.pitch = readF1000(is);
- sound_place_failed.pitch = readF1000(is);
inventory_overlay = deSerializeString(is);
wield_overlay = deSerializeString(is);
//} catch(SerializationError &e) {};
}
+
/*
CItemDefManager
*/
throw SerializationError("ERROR: Not writing dummy block.");
}
- writeU8(os, 1); // version
- writeF1000(os, 0); // deprecated heat
- writeF1000(os, 0); // deprecated humidity
+ writeU8(os, 2); // version
}
void MapBlock::deSerialize(std::istream &is, u8 version, bool disk)
void MapBlock::deSerializeNetworkSpecific(std::istream &is)
{
try {
- int version = readU8(is);
+ const u8 version = readU8(is);
//if(version != 1)
// throw SerializationError("unsupported MapBlock version");
- if(version >= 1) {
- readF1000(is); // deprecated heat
- readF1000(is); // deprecated humidity
- }
- }
- catch(SerializationError &e)
- {
+
+ } catch(SerializationError &e) {
warningstream<<"MapBlock::deSerializeNetworkSpecific(): Ignoring an error"
<<": "<<e.what()<<std::endl;
}
std::string datastring(pkt->getString(0), pkt->getSize());
std::istringstream is(datastring, std::ios_base::binary);
- v3f pos = readV3F1000(is);
- v3f vel = readV3F1000(is);
- v3f acc = readV3F1000(is);
- float expirationtime = readF1000(is);
- float size = readF1000(is);
+ v3f pos = readV3F32(is);
+ v3f vel = readV3F32(is);
+ v3f acc = readV3F32(is);
+ float expirationtime = readF32(is);
+ float size = readF32(is);
bool collisiondetection = readU8(is);
std::string texture = deSerializeLongString(is);
{
checkDataSize(4);
- writeF1000(&m_data[m_read_offset], src);
+ writeF32(&m_data[m_read_offset], src);
m_read_offset += 4;
return *this;
{
checkReadOffset(m_read_offset, 4);
- dst = readF1000(&m_data[m_read_offset]);
+ dst = readF32(&m_data[m_read_offset]);
m_read_offset += 4;
return *this;
{
checkReadOffset(m_read_offset, 8);
- dst = readV2F1000(&m_data[m_read_offset]);
+ dst = readV2F32(&m_data[m_read_offset]);
m_read_offset += 8;
return *this;
{
checkReadOffset(m_read_offset, 12);
- dst = readV3F1000(&m_data[m_read_offset]);
+ dst = readV3F32(&m_data[m_read_offset]);
m_read_offset += 12;
return *this;
Redo detached inventory sending
Add TOCLIENT_NODEMETA_CHANGED
New network float format
+ ContentFeatures version 13
*/
#define LATEST_PROTOCOL_VERSION 37
void NodeBox::serialize(std::ostream &os, u16 protocol_version) const
{
// Protocol >= 36
- int version = 5;
+ const u8 version = 6;
writeU8(os, version);
switch (type) {
writeU16(os, fixed.size());
for (const aabb3f &nodebox : fixed) {
- writeV3F1000(os, nodebox.MinEdge);
- writeV3F1000(os, nodebox.MaxEdge);
+ writeV3F32(os, nodebox.MinEdge);
+ writeV3F32(os, nodebox.MaxEdge);
}
break;
case NODEBOX_WALLMOUNTED:
writeU8(os, type);
- writeV3F1000(os, wall_top.MinEdge);
- writeV3F1000(os, wall_top.MaxEdge);
- writeV3F1000(os, wall_bottom.MinEdge);
- writeV3F1000(os, wall_bottom.MaxEdge);
- writeV3F1000(os, wall_side.MinEdge);
- writeV3F1000(os, wall_side.MaxEdge);
+ writeV3F32(os, wall_top.MinEdge);
+ writeV3F32(os, wall_top.MaxEdge);
+ writeV3F32(os, wall_bottom.MinEdge);
+ writeV3F32(os, wall_bottom.MaxEdge);
+ writeV3F32(os, wall_side.MinEdge);
+ writeV3F32(os, wall_side.MaxEdge);
break;
case NODEBOX_CONNECTED:
writeU8(os, type);
#define WRITEBOX(box) \
writeU16(os, (box).size()); \
for (const aabb3f &i: (box)) { \
- writeV3F1000(os, i.MinEdge); \
- writeV3F1000(os, i.MaxEdge); \
+ writeV3F32(os, i.MinEdge); \
+ writeV3F32(os, i.MaxEdge); \
};
WRITEBOX(fixed);
void NodeBox::deSerialize(std::istream &is)
{
int version = readU8(is);
- if (version < 4)
+ if (version < 6)
throw SerializationError("unsupported NodeBox version");
reset();
while(fixed_count--)
{
aabb3f box;
- box.MinEdge = readV3F1000(is);
- box.MaxEdge = readV3F1000(is);
+ box.MinEdge = readV3F32(is);
+ box.MaxEdge = readV3F32(is);
fixed.push_back(box);
}
}
else if(type == NODEBOX_WALLMOUNTED)
{
- wall_top.MinEdge = readV3F1000(is);
- wall_top.MaxEdge = readV3F1000(is);
- wall_bottom.MinEdge = readV3F1000(is);
- wall_bottom.MaxEdge = readV3F1000(is);
- wall_side.MinEdge = readV3F1000(is);
- wall_side.MaxEdge = readV3F1000(is);
+ wall_top.MinEdge = readV3F32(is);
+ wall_top.MaxEdge = readV3F32(is);
+ wall_bottom.MinEdge = readV3F32(is);
+ wall_bottom.MaxEdge = readV3F32(is);
+ wall_side.MinEdge = readV3F32(is);
+ wall_side.MaxEdge = readV3F32(is);
}
else if (type == NODEBOX_CONNECTED)
{
count = readU16(is); \
(box).reserve(count); \
while (count--) { \
- v3f min = readV3F1000(is); \
- v3f max = readV3F1000(is); \
+ v3f min = readV3F32(is); \
+ v3f max = readV3F32(is); \
(box).emplace_back(min, max); }; }
u16 count;
READBOXES(connect_left);
READBOXES(connect_back);
READBOXES(connect_right);
- if (version >= 5) {
- READBOXES(disconnected_top);
- READBOXES(disconnected_bottom);
- READBOXES(disconnected_front);
- READBOXES(disconnected_left);
- READBOXES(disconnected_back);
- READBOXES(disconnected_right);
- READBOXES(disconnected);
- READBOXES(disconnected_sides);
- }
+ READBOXES(disconnected_top);
+ READBOXES(disconnected_bottom);
+ READBOXES(disconnected_front);
+ READBOXES(disconnected_left);
+ READBOXES(disconnected_back);
+ READBOXES(disconnected_right);
+ READBOXES(disconnected);
+ READBOXES(disconnected_sides);
}
}
align_style = ALIGN_STYLE_NODE;
}
-
-/*
- SimpleSoundSpec serialization
-*/
-
-static void serializeSimpleSoundSpec(const SimpleSoundSpec &ss,
- std::ostream &os, u8 version)
-{
- os<<serializeString(ss.name);
- writeF1000(os, ss.gain);
- writeF1000(os, ss.pitch);
-}
-static void deSerializeSimpleSoundSpec(SimpleSoundSpec &ss,
- std::istream &is, u8 version)
-{
- ss.name = deSerializeString(is);
- ss.gain = readF1000(is);
- ss.pitch = readF1000(is);
-}
-
void TextureSettings::readSettings()
{
connected_glass = g_settings->getBool("connected_glass");
void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
{
- // protocol_version >= 36
- u8 version = 12;
+ const u8 version = CONTENTFEATURES_VERSION;
writeU8(os, version);
// general
// visual
writeU8(os, drawtype);
os << serializeString(mesh);
- writeF1000(os, visual_scale);
+ writeF32(os, visual_scale);
writeU8(os, 6);
for (const TileDef &td : tiledef)
td.serialize(os, protocol_version);
writeU16(os, connects_to_ids.size());
for (u16 connects_to_id : connects_to_ids)
writeU16(os, connects_to_id);
- writeU8(os, post_effect_color.getAlpha());
- writeU8(os, post_effect_color.getRed());
- writeU8(os, post_effect_color.getGreen());
- writeU8(os, post_effect_color.getBlue());
+ writeARGB8(os, post_effect_color);
writeU8(os, leveled);
// lighting
collision_box.serialize(os, protocol_version);
// sound
- serializeSimpleSoundSpec(sound_footstep, os, version);
- serializeSimpleSoundSpec(sound_dig, os, version);
- serializeSimpleSoundSpec(sound_dug, os, version);
+ sound_footstep.serialize(os, version);
+ sound_dig.serialize(os, version);
+ sound_dug.serialize(os, version);
// legacy
writeU8(os, legacy_facedir_simple);
void ContentFeatures::deSerialize(std::istream &is)
{
// version detection
- int version = readU8(is);
- if (version < 12)
+ const u8 version = readU8(is);
+ if (version < CONTENTFEATURES_VERSION)
throw SerializationError("unsupported ContentFeatures version");
// general
// visual
drawtype = (enum NodeDrawType) readU8(is);
mesh = deSerializeString(is);
- visual_scale = readF1000(is);
+ visual_scale = readF32(is);
if (readU8(is) != 6)
throw SerializationError("unsupported tile count");
for (TileDef &td : tiledef)
connects_to_ids.clear();
for (u16 i = 0; i < connects_to_size; i++)
connects_to_ids.push_back(readU16(is));
- post_effect_color.setAlpha(readU8(is));
- post_effect_color.setRed(readU8(is));
- post_effect_color.setGreen(readU8(is));
- post_effect_color.setBlue(readU8(is));
+ post_effect_color = readARGB8(is);
leveled = readU8(is);
// lighting-related
collision_box.deSerialize(is);
// sounds
- deSerializeSimpleSoundSpec(sound_footstep, is, version);
- deSerializeSimpleSoundSpec(sound_dig, is, version);
- deSerializeSimpleSoundSpec(sound_dug, is, version);
+ sound_footstep.deSerialize(is, version);
+ sound_dig.deSerialize(is, version);
+ sound_dug.deSerialize(is, version);
// read legacy properties
legacy_facedir_simple = readU8(is);
#include "constants.h" // BS
#include "tileanimation.h"
+// PROTOCOL_VERSION >= 37
+static const u8 CONTENTFEATURES_VERSION = 13;
+
class IItemDefManager;
class ITextureSource;
class IShaderSource;
os << ", collisionbox=" << PP(collisionbox.MinEdge) << "," << PP(collisionbox.MaxEdge);
os << ", visual=" << visual;
os << ", mesh=" << mesh;
- os << ", visual_size=" << PP2(visual_size);
+ os << ", visual_size=" << PP(visual_size);
os << ", textures=[";
for (const std::string &texture : textures) {
os << "\"" << texture << "\" ";
void ObjectProperties::serialize(std::ostream &os) const
{
- writeU8(os, 3); // version, protocol_version >= 36
+ writeU8(os, 4); // PROTOCOL_VERSION >= 37
writeS16(os, hp_max);
writeU8(os, physical);
- writeF1000(os, weight);
- writeV3F1000(os, collisionbox.MinEdge);
- writeV3F1000(os, collisionbox.MaxEdge);
- writeV3F1000(os, selectionbox.MinEdge);
- writeV3F1000(os, selectionbox.MaxEdge);
+ writeF32(os, weight);
+ writeV3F32(os, collisionbox.MinEdge);
+ writeV3F32(os, collisionbox.MaxEdge);
+ writeV3F32(os, selectionbox.MinEdge);
+ writeV3F32(os, selectionbox.MaxEdge);
writeU8(os, pointable);
os << serializeString(visual);
- writeV2F1000(os, visual_size);
+ writeV3F32(os, visual_size);
writeU16(os, textures.size());
for (const std::string &texture : textures) {
os << serializeString(texture);
writeV2S16(os, initial_sprite_basepos);
writeU8(os, is_visible);
writeU8(os, makes_footstep_sound);
- writeF1000(os, automatic_rotate);
+ writeF32(os, automatic_rotate);
// Added in protocol version 14
os << serializeString(mesh);
writeU16(os, colors.size());
writeARGB8(os, color);
}
writeU8(os, collideWithObjects);
- writeF1000(os, stepheight);
+ writeF32(os, stepheight);
writeU8(os, automatic_face_movement_dir);
- writeF1000(os, automatic_face_movement_dir_offset);
+ writeF32(os, automatic_face_movement_dir_offset);
writeU8(os, backface_culling);
os << serializeString(nametag);
writeARGB8(os, nametag_color);
- writeF1000(os, automatic_face_movement_max_rotation_per_sec);
+ writeF32(os, automatic_face_movement_max_rotation_per_sec);
os << serializeString(infotext);
os << serializeString(wield_item);
writeS8(os, glow);
writeU16(os, breath_max);
- writeF1000(os, eye_height);
- writeF1000(os, zoom_fov);
+ writeF32(os, eye_height);
+ writeF32(os, zoom_fov);
writeU8(os, use_texture_alpha);
// Add stuff only at the bottom.
void ObjectProperties::deSerialize(std::istream &is)
{
int version = readU8(is);
- if (version != 3)
+ if (version != 4)
throw SerializationError("unsupported ObjectProperties version");
hp_max = readS16(is);
physical = readU8(is);
- weight = readF1000(is);
- collisionbox.MinEdge = readV3F1000(is);
- collisionbox.MaxEdge = readV3F1000(is);
- selectionbox.MinEdge = readV3F1000(is);
- selectionbox.MaxEdge = readV3F1000(is);
+ weight = readF32(is);
+ collisionbox.MinEdge = readV3F32(is);
+ collisionbox.MaxEdge = readV3F32(is);
+ selectionbox.MinEdge = readV3F32(is);
+ selectionbox.MaxEdge = readV3F32(is);
pointable = readU8(is);
visual = deSerializeString(is);
- visual_size = readV2F1000(is);
+ visual_size = readV3F32(is);
textures.clear();
u32 texture_count = readU16(is);
for (u32 i = 0; i < texture_count; i++){
initial_sprite_basepos = readV2S16(is);
is_visible = readU8(is);
makes_footstep_sound = readU8(is);
- automatic_rotate = readF1000(is);
+ automatic_rotate = readF32(is);
mesh = deSerializeString(is);
colors.clear();
u32 color_count = readU16(is);
colors.push_back(readARGB8(is));
}
collideWithObjects = readU8(is);
- stepheight = readF1000(is);
+ stepheight = readF32(is);
automatic_face_movement_dir = readU8(is);
- automatic_face_movement_dir_offset = readF1000(is);
+ automatic_face_movement_dir_offset = readF32(is);
backface_culling = readU8(is);
nametag = deSerializeString(is);
nametag_color = readARGB8(is);
- automatic_face_movement_max_rotation_per_sec = readF1000(is);
+ automatic_face_movement_max_rotation_per_sec = readF32(is);
infotext = deSerializeString(is);
wield_item = deSerializeString(is);
glow = readS8(is);
breath_max = readU16(is);
- eye_height = readF1000(is);
- zoom_fov = readF1000(is);
+ eye_height = readF32(is);
+ zoom_fov = readF32(is);
use_texture_alpha = readU8(is);
}
bool pointable = true;
std::string visual = "sprite";
std::string mesh = "";
- v2f visual_size = v2f(1, 1);
+ v3f visual_size = v3f(1, 1, 1);
std::vector<std::string> textures;
std::vector<video::SColor> colors;
v2s16 spritediv = v2s16(1, 1);
getstringfield(L, -1, "mesh", prop->mesh);
lua_getfield(L, -1, "visual_size");
- if(lua_istable(L, -1))
- prop->visual_size = read_v2f(L, -1);
+ if (lua_istable(L, -1)) {
+ // Backwards compatibility: Also accept { x = ?, y = ? }
+ v2f scale_xy = read_v2f(L, -1);
+
+ f32 scale_z = scale_xy.X;
+ lua_getfield(L, -1, "z");
+ if (lua_isnumber(L, -1))
+ scale_z = lua_tonumber(L, -1);
+ lua_pop(L, 1);
+
+ prop->visual_size = v3f(scale_xy.X, scale_xy.Y, scale_z);
+ }
lua_pop(L, 1);
lua_getfield(L, -1, "textures");
lua_setfield(L, -2, "visual");
lua_pushlstring(L, prop->mesh.c_str(), prop->mesh.size());
lua_setfield(L, -2, "mesh");
- push_v2f(L, prop->visual_size);
+ push_v3f(L, prop->visual_size);
lua_setfield(L, -2, "visual_size");
lua_newtable(L);
#include <set>
#include <string>
+#include "util/serialize.h"
#include "irrlichttypes_bloated.h"
struct SimpleSoundSpec
bool exists() const { return !name.empty(); }
+ // Take cf_version from ContentFeatures::serialize to
+ // keep in sync with item definitions
+ void serialize(std::ostream &os, u8 cf_version) const
+ {
+ os << serializeString(name);
+ writeF32(os, gain);
+ writeF32(os, pitch);
+ writeF32(os, fade);
+ // if (cf_version < ?)
+ // return;
+ }
+
+ void deSerialize(std::istream &is, u8 cf_version)
+ {
+ name = deSerializeString(is);
+ gain = readF32(is);
+ pitch = readF32(is);
+ fade = readF32(is);
+ }
+
std::string name;
float gain = 1.0f;
float fade = 0.0f;
if (type == TAT_VERTICAL_FRAMES) {
writeU16(os, vertical_frames.aspect_w);
writeU16(os, vertical_frames.aspect_h);
- writeF1000(os, vertical_frames.length);
+ writeF32(os, vertical_frames.length);
} else if (type == TAT_SHEET_2D) {
writeU8(os, sheet_2d.frames_w);
writeU8(os, sheet_2d.frames_h);
- writeF1000(os, sheet_2d.frame_length);
+ writeF32(os, sheet_2d.frame_length);
}
}
if (type == TAT_VERTICAL_FRAMES) {
vertical_frames.aspect_w = readU16(is);
vertical_frames.aspect_h = readU16(is);
- vertical_frames.length = readF1000(is);
+ vertical_frames.length = readF32(is);
} else if (type == TAT_SHEET_2D) {
sheet_2d.frames_w = readU8(is);
sheet_2d.frames_h = readU8(is);
- sheet_2d.frame_length = readF1000(is);
+ sheet_2d.frame_length = readF32(is);
}
}
void ToolCapabilities::serialize(std::ostream &os, u16 protocol_version) const
{
- writeU8(os, 3); // protocol_version >= 36
- writeF1000(os, full_punch_interval);
+ writeU8(os, 4); // protocol_version >= 37
+ writeF32(os, full_punch_interval);
writeS16(os, max_drop_level);
writeU32(os, groupcaps.size());
for (const auto &groupcap : groupcaps) {
writeU32(os, cap->times.size());
for (const auto &time : cap->times) {
writeS16(os, time.first);
- writeF1000(os, time.second);
+ writeF32(os, time.second);
}
}
void ToolCapabilities::deSerialize(std::istream &is)
{
int version = readU8(is);
- if (version < 3)
+ if (version < 4)
throw SerializationError("unsupported ToolCapabilities version");
- full_punch_interval = readF1000(is);
+ full_punch_interval = readF32(is);
max_drop_level = readS16(is);
groupcaps.clear();
u32 groupcaps_size = readU32(is);
u32 times_size = readU32(is);
for(u32 i = 0; i < times_size; i++) {
int level = readS16(is);
- float time = readF1000(is);
+ float time = readF32(is);
cap.times[level] = time;
}
groupcaps[name] = cap;
std::wstring teststring2_w;
std::string teststring2_w_encoded;
- static const u8 test_serialized_data[12 * 13];
+ static const u8 test_serialized_data[12 * 13 - 8];
};
static TestSerialization g_test_instance;
UASSERT(readV3S16(is) == v3s16(4207, 604, -30));
UASSERT(readV2S32(is) == v2s32(1920, 1080));
UASSERT(readV3S32(is) == v3s32(-400, 6400054, 290549855));
- UASSERT(readV2F1000(is) == v2f(500.656f, 350.345f));
UASSERT(deSerializeWideString(is) == L"\x02~woof~\x5455");
writeV3S16(os, v3s16(4207, 604, -30));
writeV2S32(os, v2s32(1920, 1080));
writeV3S32(os, v3s32(-400, 6400054, 290549855));
- writeV2F1000(os, v2f(500.65661f, 350.34567f));
os << serializeWideString(L"\x02~woof~\x5455");
putV3S16(&buf, v3s16(4207, 604, -30));
putV2S32(&buf, v2s32(1920, 1080));
putV3S32(&buf, v3s32(-400, 6400054, 290549855));
- putV2F1000(&buf, v2f(500.65661f, 350.34567f));
putWideString(&buf, L"\x02~woof~\x5455");
v3s16 v3s16_data;
v2s32 v2s32_data;
v3s32 v3s32_data;
- v2f v2f_data;
v3f v3f_data;
std::string string_data;
std::wstring widestring_data;
UASSERT(buf.getV3S16() == v3s16(4207, 604, -30));
UASSERT(buf.getV2S32() == v2s32(1920, 1080));
UASSERT(buf.getV3S32() == v3s32(-400, 6400054, 290549855));
- UASSERT(buf.getV2F1000() == v2f(500.656f, 350.345f));
UASSERT(buf.getWideString() == L"\x02~woof~\x5455");
UASSERT(buf.getV3F1000() == v3f(500, 10024.2f, -192.54f));
UASSERT(buf.getARGB8() == video::SColor(255, 128, 50, 128));
EXCEPTION_CHECK(SerializationError, buf.getV3S16());
EXCEPTION_CHECK(SerializationError, buf.getV2S32());
EXCEPTION_CHECK(SerializationError, buf.getV3S32());
- EXCEPTION_CHECK(SerializationError, buf.getV2F1000());
EXCEPTION_CHECK(SerializationError, buf.getV3F1000());
EXCEPTION_CHECK(SerializationError, buf.getString());
UASSERT(buf.getV3S16NoEx(&v3s16_data));
UASSERT(buf.getV2S32NoEx(&v2s32_data));
UASSERT(buf.getV3S32NoEx(&v3s32_data));
- UASSERT(buf.getV2F1000NoEx(&v2f_data));
UASSERT(buf.getWideStringNoEx(&widestring_data));
UASSERT(buf.getV3F1000NoEx(&v3f_data));
UASSERT(buf.getARGB8NoEx(&scolor_data));
UASSERT(v3s16_data == v3s16(4207, 604, -30));
UASSERT(v2s32_data == v2s32(1920, 1080));
UASSERT(v3s32_data == v3s32(-400, 6400054, 290549855));
- UASSERT(v2f_data == v2f(500.656f, 350.345f));
UASSERT(widestring_data == L"\x02~woof~\x5455");
UASSERT(v3f_data == v3f(500, 10024.2f, -192.54f));
UASSERT(scolor_data == video::SColor(255, 128, 50, 128));
UASSERT(!buf.getV3S16NoEx(&v3s16_data));
UASSERT(!buf.getV2S32NoEx(&v2s32_data));
UASSERT(!buf.getV3S32NoEx(&v3s32_data));
- UASSERT(!buf.getV2F1000NoEx(&v2f_data));
UASSERT(!buf.getV3F1000NoEx(&v3f_data));
UASSERT(!buf.getStringNoEx(&string_data));
UASSERT(test_single(i));
}
-const u8 TestSerialization::test_serialized_data[12 * 13] = {
+const u8 TestSerialization::test_serialized_data[12 * 13 - 8] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc,
0xdd, 0xee, 0xff, 0x80, 0x75, 0x30, 0xff, 0xff, 0xff, 0xfa, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x00, 0x00, 0xd1, 0x1e, 0xee, 0x1e,
0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72, 0x21, 0x01, 0xf4, 0x01, 0xf4, 0x10,
0x6f, 0x02, 0x5c, 0xff, 0xe2, 0x00, 0x00, 0x07, 0x80, 0x00, 0x00, 0x04,
0x38, 0xff, 0xff, 0xfe, 0x70, 0x00, 0x61, 0xa8, 0x36, 0x11, 0x51, 0x70,
- 0x5f, 0x00, 0x07, 0xa3, 0xb0, 0x00, 0x05, 0x58, 0x89, 0x00, 0x08, 0x00,
- 0x02, 0x00, 0x7e, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x66, 0x00,
+ 0x5f, 0x00, 0x08, 0x00,
+ 0x02, 0x00, 0x7e, 0x00, 'w', 0x00, 'o', 0x00, 'o', 0x00, 'f', 0x00, // \x02~woof~\x5455
0x7e, 0x54, 0x55, 0x00, 0x07, 0xa1, 0x20, 0x00, 0x98, 0xf5, 0x08, 0xff,
0xfd, 0x0f, 0xe4, 0xff, 0x80, 0x32, 0x80, 0x00, 0x00, 0x00, 0x17, 0x73,
0x6f, 0x6d, 0x65, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x20, 0x73,
return p;
}
-inline v2f readV2F1000(const u8 *data)
+inline v3f readV3F1000(const u8 *data)
{
- v2f p;
- p.X = (float)readF1000(&data[0]);
- p.Y = (float)readF1000(&data[4]);
+ v3f p;
+ p.X = readF1000(&data[0]);
+ p.Y = readF1000(&data[4]);
+ p.Z = readF1000(&data[8]);
return p;
}
-inline v3f readV3F1000(const u8 *data)
+inline v2f readV2F32(const u8 *data)
{
- v3f p;
- p.X = (float)readF1000(&data[0]);
- p.Y = (float)readF1000(&data[4]);
- p.Z = (float)readF1000(&data[8]);
+ v2f p;
+ p.X = readF32(&data[0]);
+ p.Y = readF32(&data[4]);
return p;
}
inline v3f readV3F32(const u8 *data)
{
v3f p;
- p.X = (float)readF32(&data[0]);
- p.Y = (float)readF32(&data[4]);
- p.Z = (float)readF32(&data[8]);
+ p.X = readF32(&data[0]);
+ p.Y = readF32(&data[4]);
+ p.Z = readF32(&data[8]);
return p;
}
writeS32(&data[8], p.Z);
}
-inline void writeV2F1000(u8 *data, v2f p)
+inline void writeV3F1000(u8 *data, v3f p)
{
writeF1000(&data[0], p.X);
writeF1000(&data[4], p.Y);
+ writeF1000(&data[8], p.Z);
}
-inline void writeV3F1000(u8 *data, v3f p)
+inline void writeV2F32(u8 *data, v2f p)
{
- writeF1000(&data[0], p.X);
- writeF1000(&data[4], p.Y);
- writeF1000(&data[8], p.Z);
+ writeF32(&data[0], p.X);
+ writeF32(&data[4], p.Y);
}
inline void writeV3F32(u8 *data, v3f p)
MAKE_STREAM_READ_FXN(v3s16, V3S16, 6);
MAKE_STREAM_READ_FXN(v2s32, V2S32, 8);
MAKE_STREAM_READ_FXN(v3s32, V3S32, 12);
-MAKE_STREAM_READ_FXN(v2f, V2F1000, 8);
MAKE_STREAM_READ_FXN(v3f, V3F1000, 12);
+MAKE_STREAM_READ_FXN(v2f, V2F32, 8);
MAKE_STREAM_READ_FXN(v3f, V3F32, 12);
MAKE_STREAM_READ_FXN(video::SColor, ARGB8, 4);
MAKE_STREAM_WRITE_FXN(v3s16, V3S16, 6);
MAKE_STREAM_WRITE_FXN(v2s32, V2S32, 8);
MAKE_STREAM_WRITE_FXN(v3s32, V3S32, 12);
-MAKE_STREAM_WRITE_FXN(v2f, V2F1000, 8);
MAKE_STREAM_WRITE_FXN(v3f, V3F1000, 12);
+MAKE_STREAM_WRITE_FXN(v2f, V2F32, 8);
MAKE_STREAM_WRITE_FXN(v3f, V3F32, 12);
MAKE_STREAM_WRITE_FXN(video::SColor, ARGB8, 4);
MAKE_BUFREADER_GETNOEX_FXN(v3s16, V3S16, 6);
MAKE_BUFREADER_GETNOEX_FXN(v2s32, V2S32, 8);
MAKE_BUFREADER_GETNOEX_FXN(v3s32, V3S32, 12);
- MAKE_BUFREADER_GETNOEX_FXN(v2f, V2F1000, 8);
MAKE_BUFREADER_GETNOEX_FXN(v3f, V3F1000, 12);
MAKE_BUFREADER_GETNOEX_FXN(video::SColor, ARGB8, 4);
MAKE_BUFREADER_GET_FXN(v3s16, V3S16);
MAKE_BUFREADER_GET_FXN(v2s32, V2S32);
MAKE_BUFREADER_GET_FXN(v3s32, V3S32);
- MAKE_BUFREADER_GET_FXN(v2f, V2F1000);
MAKE_BUFREADER_GET_FXN(v3f, V3F1000);
MAKE_BUFREADER_GET_FXN(video::SColor, ARGB8);
MAKE_BUFREADER_GET_FXN(std::string, String);
putS32(dest, val.Z);
}
-inline void putV2F1000(std::vector<u8> *dest, v2f val)
-{
- putF1000(dest, val.X);
- putF1000(dest, val.Y);
-}
-
inline void putV3F1000(std::vector<u8> *dest, v3f val)
{
putF1000(dest, val.X);
projects / oweals / minetest.git / commitdiff