String CSSPrimitiveValue::customCSSText() const
{
if (m_hasCachedCSSText) {
ASSERT(cssTextCache().contains(this));
return cssTextCache().get(this);
}
String text;
switch (type()) {
case UnitType::Unknown:
// FIXME
break;
case UnitType::Integer:
text = String::format("%d", getIntValue());
break;
case UnitType::Number:
case UnitType::Percentage:
case UnitType::Ems:
case UnitType::QuirkyEms:
case UnitType::Exs:
case UnitType::Rems:
case UnitType::Chs:
case UnitType::Pixels:
case UnitType::Centimeters:
case UnitType::DotsPerPixel:
case UnitType::DotsPerInch:
case UnitType::DotsPerCentimeter:
case UnitType::Millimeters:
case UnitType::Inches:
case UnitType::Points:
case UnitType::Picas:
case UnitType::Degrees:
case UnitType::Radians:
case UnitType::Gradians:
case UnitType::Milliseconds:
case UnitType::Seconds:
case UnitType::Hertz:
case UnitType::Kilohertz:
case UnitType::Turns:
case UnitType::Fraction:
case UnitType::ViewportWidth:
case UnitType::ViewportHeight:
case UnitType::ViewportMin:
case UnitType::ViewportMax:
text = formatNumber(m_value.num, unitTypeToString(type()));
break;
case UnitType::CustomIdentifier:
text = quoteCSSStringIfNeeded(m_value.string);
break;
case UnitType::String: {
text = serializeString(m_value.string);
break;
}
case UnitType::URI:
text = serializeURI(m_value.string);
break;
case UnitType::ValueID:
text = valueName(m_value.valueID);
break;
case UnitType::PropertyID:
text = propertyName(m_value.propertyID);
break;
case UnitType::RGBColor: {
text = Color(m_value.rgbcolor).serializedAsCSSComponentValue();
break;
}
case UnitType::Calc:
text = m_value.calc->customCSSText();
break;
case UnitType::CalcPercentageWithNumber:
case UnitType::CalcPercentageWithLength:
ASSERT_NOT_REACHED();
break;
}
ASSERT(!cssTextCache().contains(this));
cssTextCache().set(this, text);
m_hasCachedCSSText = true;
return text;
}
static void serializeSimpleSoundSpec(const SimpleSoundSpec &ss,
std::ostream &os)
{
os<<serializeString(ss.name);
writeF1000(os, ss.gain);
}
void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
{
if(protocol_version < 24){
serializeOld(os, protocol_version);
return;
}
writeU8(os, protocol_version < 27 ? 7 : 8);
os<<serializeString(name);
writeU16(os, groups.size());
for(ItemGroupList::const_iterator
i = groups.begin(); i != groups.end(); ++i){
os<<serializeString(i->first);
writeS16(os, i->second);
}
writeU8(os, drawtype);
writeF1000(os, visual_scale);
writeU8(os, 6);
for(u32 i = 0; i < 6; i++)
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, protocol_version);
}
writeU8(os, alpha);
writeU8(os, post_effect_color.getAlpha());
writeU8(os, post_effect_color.getRed());
writeU8(os, post_effect_color.getGreen());
writeU8(os, post_effect_color.getBlue());
writeU8(os, param_type);
writeU8(os, param_type_2);
writeU8(os, is_ground_content);
writeU8(os, light_propagates);
writeU8(os, sunlight_propagates);
writeU8(os, walkable);
writeU8(os, pointable);
writeU8(os, diggable);
writeU8(os, climbable);
writeU8(os, buildable_to);
os<<serializeString(""); // legacy: used to be metadata_name
writeU8(os, liquid_type);
os<<serializeString(liquid_alternative_flowing);
os<<serializeString(liquid_alternative_source);
writeU8(os, liquid_viscosity);
writeU8(os, liquid_renewable);
writeU8(os, light_source);
writeU32(os, damage_per_second);
node_box.serialize(os, protocol_version);
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);
writeU8(os, rightclickable);
writeU8(os, drowning);
writeU8(os, leveled);
writeU8(os, liquid_range);
writeU8(os, waving);
// Stuff below should be moved to correct place in a version that otherwise changes
// the protocol version
os<<serializeString(mesh);
collision_box.serialize(os, protocol_version);
writeU8(os, floodable);
}
inline void serializeEncodedString(SF::Archive & ar, std::basic_string<C,T,A> & ws)
{
if (ar.getRuntimeVersion() < 8)
{
serializeString(ar, ws);
return;
}
RCF_ASSERT_GTEQ(ar.getRuntimeVersion() , 8);
if (ar.isRead())
{
int encodingType = 0;
ar & encodingType;
if (encodingType == 8)
{
// UTF-8 serialization.
std::string s;
ar & s;
ws = RcfBoost::boost::from_utf8(s);
}
else
{
// Native wchar_t serialization.
RCF_VERIFY(
encodingType == sizeof(wchar_t),
RCF::Exception(
RCF::_RcfError_WcharSizeMismatch(sizeof(wchar_t), encodingType)));
serializeString(ar, ws);
}
}
else if (ar.isWrite())
{
bool useNativeWstringSerialization = SF::getCurrentNativeWstringSerialization();
int encodingType = sizeof(wchar_t);
if (useNativeWstringSerialization)
{
encodingType = sizeof(wchar_t);
}
else
{
encodingType = 8;
}
ar & encodingType;
if (encodingType == 8)
{
// UTF-8 serialization.
std::string s = RcfBoost::boost::to_utf8(ws);
ar & s;
}
else
{
// Native wchar_t serialization.
RCF_VERIFY(
encodingType == sizeof(wchar_t),
RCF::Exception(
RCF::_RcfError_WcharSizeMismatch(sizeof(wchar_t), encodingType)));
serializeString(ar, ws);
}
}
}
//// Serialization of old ContentFeatures formats
void ContentFeatures::serializeOld(std::ostream &os, u16 protocol_version) const
{
if (protocol_version == 13)
{
writeU8(os, 5); // version
os<<serializeString(name);
writeU16(os, groups.size());
for (ItemGroupList::const_iterator
i = groups.begin(); i != groups.end(); ++i) {
os<<serializeString(i->first);
writeS16(os, i->second);
}
writeU8(os, drawtype);
writeF1000(os, visual_scale);
writeU8(os, 6);
for (u32 i = 0; i < 6; i++)
tiledef[i].serialize(os, protocol_version);
//CF_SPECIAL_COUNT = 2 before cf ver. 7 and protocol ver. 24
writeU8(os, 2);
for (u32 i = 0; i < 2; i++)
tiledef_special[i].serialize(os, protocol_version);
writeU8(os, alpha);
writeU8(os, post_effect_color.getAlpha());
writeU8(os, post_effect_color.getRed());
writeU8(os, post_effect_color.getGreen());
writeU8(os, post_effect_color.getBlue());
writeU8(os, param_type);
writeU8(os, param_type_2);
writeU8(os, is_ground_content);
writeU8(os, light_propagates);
writeU8(os, sunlight_propagates);
writeU8(os, walkable);
writeU8(os, pointable);
writeU8(os, diggable);
writeU8(os, climbable);
writeU8(os, buildable_to);
os<<serializeString(""); // legacy: used to be metadata_name
writeU8(os, liquid_type);
os<<serializeString(liquid_alternative_flowing);
os<<serializeString(liquid_alternative_source);
writeU8(os, liquid_viscosity);
writeU8(os, light_source);
writeU32(os, damage_per_second);
node_box.serialize(os, protocol_version);
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);
}
else if (protocol_version > 13 && protocol_version < 24) {
writeU8(os, 6); // version
os<<serializeString(name);
writeU16(os, groups.size());
for (ItemGroupList::const_iterator
i = groups.begin(); i != groups.end(); ++i) {
os<<serializeString(i->first);
writeS16(os, i->second);
}
writeU8(os, drawtype);
writeF1000(os, visual_scale);
writeU8(os, 6);
for (u32 i = 0; i < 6; i++)
tiledef[i].serialize(os, protocol_version);
//CF_SPECIAL_COUNT = 2 before cf ver. 7 and protocol ver. 24
writeU8(os, 2);
for (u32 i = 0; i < 2; i++)
tiledef_special[i].serialize(os, protocol_version);
writeU8(os, alpha);
writeU8(os, post_effect_color.getAlpha());
writeU8(os, post_effect_color.getRed());
writeU8(os, post_effect_color.getGreen());
writeU8(os, post_effect_color.getBlue());
writeU8(os, param_type);
writeU8(os, param_type_2);
writeU8(os, is_ground_content);
writeU8(os, light_propagates);
writeU8(os, sunlight_propagates);
writeU8(os, walkable);
writeU8(os, pointable);
writeU8(os, diggable);
writeU8(os, climbable);
writeU8(os, buildable_to);
os<<serializeString(""); // legacy: used to be metadata_name
writeU8(os, liquid_type);
os<<serializeString(liquid_alternative_flowing);
os<<serializeString(liquid_alternative_source);
writeU8(os, liquid_viscosity);
writeU8(os, liquid_renewable);
writeU8(os, light_source);
writeU32(os, damage_per_second);
node_box.serialize(os, protocol_version);
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);
writeU8(os, rightclickable);
writeU8(os, drowning);
writeU8(os, leveled);
writeU8(os, liquid_range);
} else
throw SerializationError("ContentFeatures::serialize(): "
"Unsupported version requested");
}
inline void serializeEncodedStringOrNot(SF::Archive & ar, std::basic_string<C, T, A> & t, boost::mpl::false_ *)
{
serializeString(ar, t);
}
inline void serialize_vc6(SF::Archive & ar, std::basic_string<C,T,A> & t, const unsigned int)
{
serializeString(ar, t);
}
void CraftDefinition::serialize(std::ostream &os) const
{
writeU8(os, 1); // version
os<<serializeString(getName());
serializeBody(os);
}
void CSSParserToken::serialize(StringBuilder& builder) const
{
// This is currently only used for @supports CSSOM. To keep our implementation
// simple we handle some of the edge cases incorrectly (see comments below).
switch (type()) {
case IdentToken:
serializeIdentifier(value().toString(), builder);
break;
case FunctionToken:
serializeIdentifier(value().toString(), builder);
return builder.append('(');
case AtKeywordToken:
builder.append('@');
serializeIdentifier(value().toString(), builder);
break;
case HashToken:
builder.append('#');
serializeIdentifier(value().toString(), builder, (getHashTokenType() == HashTokenUnrestricted));
break;
case UrlToken:
builder.append("url(");
serializeIdentifier(value().toString(), builder);
return builder.append(")");
case DelimiterToken:
if (delimiter() == '\\')
return builder.append("\\\n");
return builder.append(delimiter());
case NumberToken:
// These won't properly preserve the NumericValueType flag
return builder.appendNumber(numericValue());
case PercentageToken:
builder.appendNumber(numericValue());
return builder.append('%');
case DimensionToken:
// This will incorrectly serialize e.g. 4e3e2 as 4000e2
builder.appendNumber(numericValue());
serializeIdentifier(value().toString(), builder);
break;
case UnicodeRangeToken:
return builder.append(String::format("U+%X-%X", unicodeRangeStart(), unicodeRangeEnd()));
case StringToken:
return serializeString(value().toString(), builder);
case IncludeMatchToken:
return builder.append("~=");
case DashMatchToken:
return builder.append("|=");
case PrefixMatchToken:
return builder.append("^=");
case SuffixMatchToken:
return builder.append("$=");
case SubstringMatchToken:
return builder.append("*=");
case ColumnToken:
return builder.append("||");
case CDOToken:
return builder.append("<!--");
case CDCToken:
return builder.append("-->");
case BadStringToken:
return builder.append("'\n");
case BadUrlToken:
return builder.append("url(()");
case WhitespaceToken:
return builder.append(' ');
case ColonToken:
return builder.append(':');
case SemicolonToken:
return builder.append(';');
case CommaToken:
return builder.append(',');
case LeftParenthesisToken:
return builder.append('(');
case RightParenthesisToken:
return builder.append(')');
case LeftBracketToken:
return builder.append('[');
case RightBracketToken:
return builder.append(']');
case LeftBraceToken:
return builder.append('{');
case RightBraceToken:
return builder.append('}');
case EOFToken:
case CommentToken:
ASSERT_NOT_REACHED();
return;
}
}
void CraftDefinitionFuel::serializeBody(std::ostream &os) const
{
os<<serializeString(recipe);
writeF1000(os, burntime);
replacements.serialize(os);
}
void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
{
const u8 version = CONTENTFEATURES_VERSION;
writeU8(os, version);
// general
os << serializeString(name);
writeU16(os, groups.size());
for (const auto &group : groups) {
os << serializeString(group.first);
writeS16(os, group.second);
}
writeU8(os, param_type);
writeU8(os, param_type_2);
// visual
writeU8(os, drawtype);
os << serializeString(mesh);
writeF32(os, visual_scale);
writeU8(os, 6);
for (const TileDef &td : tiledef)
td.serialize(os, protocol_version);
for (const TileDef &td : tiledef_overlay)
td.serialize(os, protocol_version);
writeU8(os, CF_SPECIAL_COUNT);
for (const TileDef &td : tiledef_special) {
td.serialize(os, protocol_version);
}
writeU8(os, alpha);
writeU8(os, color.getRed());
writeU8(os, color.getGreen());
writeU8(os, color.getBlue());
os << serializeString(palette_name);
writeU8(os, waving);
writeU8(os, connect_sides);
writeU16(os, connects_to_ids.size());
for (u16 connects_to_id : connects_to_ids)
writeU16(os, connects_to_id);
writeARGB8(os, post_effect_color);
writeU8(os, leveled);
// lighting
writeU8(os, light_propagates);
writeU8(os, sunlight_propagates);
writeU8(os, light_source);
// map generation
writeU8(os, is_ground_content);
// interaction
writeU8(os, walkable);
writeU8(os, pointable);
writeU8(os, diggable);
writeU8(os, climbable);
writeU8(os, buildable_to);
writeU8(os, rightclickable);
writeU32(os, damage_per_second);
// liquid
writeU8(os, liquid_type);
os << serializeString(liquid_alternative_flowing);
os << serializeString(liquid_alternative_source);
writeU8(os, liquid_viscosity);
writeU8(os, liquid_renewable);
writeU8(os, liquid_range);
writeU8(os, drowning);
writeU8(os, floodable);
// node boxes
node_box.serialize(os, protocol_version);
selection_box.serialize(os, protocol_version);
collision_box.serialize(os, protocol_version);
// sound
sound_footstep.serialize(os, version);
sound_dig.serialize(os, version);
sound_dug.serialize(os, version);
// legacy
writeU8(os, legacy_facedir_simple);
writeU8(os, legacy_wallmounted);
os << serializeString(node_dig_prediction);
}
void LockingChestNodeMetadata::serializeBody(std::ostream &os)
{
os<<serializeString(m_text);
m_inventory->serialize(os);
}
void SignNodeMetadata::serializeBody(std::ostream &os)
{
os<<serializeString(m_text);
}
void MapBlock::serialize_pre22(std::ostream &os, u8 version, bool disk)
{
u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
MapNode *tmp_data = new MapNode[nodecount];
// Legacy data changes
// This code has to change from post-22 to pre-22 format.
INodeDefManager *nodedef = m_gamedef->ndef();
for(u32 i=0; i<nodecount; i++)
{
const ContentFeatures &f = nodedef->get(tmp_data[i].getContent());
// Mineral
if(nodedef->getId("default:stone_with_coal") == tmp_data[i].getContent())
{
tmp_data[i].setContent(nodedef->getId("default:stone"));
tmp_data[i].setParam1(1); // MINERAL_COAL
}
else if(nodedef->getId("default:stone_with_iron") == tmp_data[i].getContent())
{
tmp_data[i].setContent(nodedef->getId("default:stone"));
tmp_data[i].setParam1(2); // MINERAL_IRON
}
// facedir_simple
if(f.legacy_facedir_simple)
{
tmp_data[i].setParam1(tmp_data[i].getParam2());
tmp_data[i].setParam2(0);
}
// wall_mounted
if(f.legacy_wallmounted)
{
u8 wallmounted_new_to_old[8] = {0x04, 0x08, 0x01, 0x02, 0x10, 0x20, 0, 0};
u8 dir_new_format = tmp_data[i].getParam2() & 7; // lowest 3 bits
u8 dir_old_format = wallmounted_new_to_old[dir_new_format];
tmp_data[i].setParam2(dir_old_format);
}
}
// Serialize nodes
u32 ser_length = MapNode::serializedLength(version);
SharedBuffer<u8> databuf_nodelist(nodecount * ser_length);
for(u32 i=0; i<nodecount; i++)
{
tmp_data[i].serialize(&databuf_nodelist[i*ser_length], version);
}
delete[] tmp_data;
// These have no compression
if(version <= 3 || version == 5 || version == 6)
{
writeU8(os, is_underground);
os.write((char*)*databuf_nodelist, databuf_nodelist.getSize());
}
else if(version <= 10)
{
/*
With compression.
Compress the materials and the params separately.
*/
// First byte
writeU8(os, is_underground);
// Get and compress materials
SharedBuffer<u8> materialdata(nodecount);
for(u32 i=0; i<nodecount; i++)
{
materialdata[i] = databuf_nodelist[i*ser_length];
}
compress(materialdata, os, version);
// Get and compress lights
SharedBuffer<u8> lightdata(nodecount);
for(u32 i=0; i<nodecount; i++)
{
lightdata[i] = databuf_nodelist[i*ser_length+1];
}
compress(lightdata, os, version);
if(version >= 10)
{
// Get and compress param2
SharedBuffer<u8> param2data(nodecount);
for(u32 i=0; i<nodecount; i++)
{
param2data[i] = databuf_nodelist[i*ser_length+2];
}
compress(param2data, os, version);
}
}
// All other versions (newest)
else
{
// First byte
u8 flags = 0;
if(is_underground)
flags |= 0x01;
if(getDayNightDiff())
flags |= 0x02;
if(m_lighting_expired)
flags |= 0x04;
if(version >= 18)
{
if(m_generated == false)
flags |= 0x08;
}
writeU8(os, flags);
/*
Get data
*/
// Create buffer with different parameters sorted
SharedBuffer<u8> databuf(nodecount*3);
for(u32 i=0; i<nodecount; i++)
{
databuf[i] = databuf_nodelist[i*ser_length];
databuf[i+nodecount] = databuf_nodelist[i*ser_length+1];
databuf[i+nodecount*2] = databuf_nodelist[i*ser_length+2];
}
/*
Compress data to output stream
*/
compress(databuf, os, version);
/*
NodeMetadata
*/
if(version >= 14)
{
if(version <= 15)
{
try{
std::ostringstream oss(std::ios_base::binary);
m_node_metadata->serialize(oss);
os<<serializeString(oss.str());
}
// This will happen if the string is longer than 65535
catch(SerializationError &e)
{
// Use an empty string
os<<serializeString("");
}
}
else
{
std::ostringstream oss(std::ios_base::binary);
m_node_metadata->serialize(oss);
compressZlib(oss.str(), os);
//os<<serializeLongString(oss.str());
}
}
}
if(disk)
{
// Versions up from 9 have block objects. (DEPRECATED)
if(version >= 9)
{
// count=0
writeU16(os, 0);
}
// Versions up from 15 have static objects.
if(version >= 15)
{
m_static_objects.serialize(os);
}
// Timestamp
if(version >= 17)
{
writeU32(os, getTimestamp());
}
// Scan and write node definition id mapping
if(version >= 21)
{
NameIdMapping nimap;
getBlockNodeIdMapping_pre22(&nimap, data, m_gamedef->ndef());
nimap.serialize(os);
}
}
}
