bool DecoSchematic::loadSchematicFile() { std::ifstream is(filename.c_str(), std::ios_base::binary); u32 signature = readU32(is); if (signature != MTSCHEM_FILE_SIGNATURE) { errorstream << "loadSchematicFile: invalid schematic " "file" << std::endl; return false; } u16 version = readU16(is); if (version != 1) { errorstream << "loadSchematicFile: unsupported schematic " "file version" << std::endl; return false; } size = readV3S16(is); int nodecount = size.X * size.Y * size.Z; u16 nidmapcount = readU16(is); node_names = new std::vector<std::string>; for (int i = 0; i != nidmapcount; i++) { std::string name = deSerializeString(is); node_names->push_back(name); } delete schematic; schematic = new MapNode[nodecount]; MapNode::deSerializeBulk(is, SER_FMT_VER_HIGHEST, schematic, nodecount, 2, 2, true); return true; }
WideString TankFile::readWNString() { auto lenInChars = readU16(); if (lenInChars == 0) { readU16(); // Waste another word to make this a dword return WideString(); } // NSTRINGs are stored aligned at dword boundary: lenInChars = alignToDword(lenInChars + 2) - 2; // 2 for the word we've just read assert(((lenInChars + 2) % sizeof(uint32_t)) == 0); if (lenInChars >= utils::MaxTempStringLen) { SiegeThrow(TankFile::Error, "String overflow in TankFile::readWNString()! " << lenInChars << " >= " << utils::MaxTempStringLen); } WideChar buffer[utils::MaxTempStringLen]; readBytes(buffer, lenInChars * sizeof(WideChar)); buffer[lenInChars] = 0; return buffer; }
void deSerialize(std::istream &is) { clear(); int version = readU8(is); if(version != 1) throw SerializationError("unsupported NodeDefinitionManager version"); u16 count = readU16(is); std::istringstream is2(deSerializeLongString(is), std::ios::binary); for(u16 n=0; n<count; n++){ u16 i = readU16(is2); if(i > MAX_CONTENT){ errorstream<<"ContentFeatures::deSerialize(): " <<"Too large content id: "<<i<<std::endl; continue; } /*// Do not deserialize special types if(i == CONTENT_IGNORE || i == CONTENT_AIR) continue;*/ ContentFeatures *f = &m_content_features[i]; // Read it from the string wrapper std::string wrapper = deSerializeString(is2); std::istringstream wrapper_is(wrapper, std::ios::binary); f->deSerialize(wrapper_is); verbosestream<<"deserialized "<<f->name<<std::endl; if(f->name != "") addNameIdMapping(i, f->name); } }
bool WPGHeader::load(WPXInputStream *input) { input->seek(0, WPX_SEEK_SET); size_t n = 0; unsigned char * prefix = (unsigned char *) input->read(26, n); if(n < 26) return false; m_identifier[0] = prefix[0]; m_identifier[1] = prefix[1]; m_identifier[2] = prefix[2]; m_identifier[3] = prefix[3]; m_startOfDocument = readU32(prefix+4); m_productType = prefix[8]; m_fileType = prefix[9]; m_majorVersion = prefix[10]; m_minorVersion = prefix[11]; m_encryptionKey = readU16(prefix+12); m_startOfPacketData = readU16(prefix+14); WPG_DEBUG_MSG(("Header Identifier = %c%c%c\n", m_identifier[1], m_identifier[2], m_identifier[3])); WPG_DEBUG_MSG(("Product type = 0x%x\n", m_productType)); WPG_DEBUG_MSG(("File type = 0x%x\n", m_fileType)); WPG_DEBUG_MSG(("Major version = 0x%x\n", m_majorVersion)); WPG_DEBUG_MSG(("Minor version = 0x%x\n", m_minorVersion)); WPG_DEBUG_MSG(("Encryption key = 0x%x\n", m_encryptionKey)); return true; }
void deSerialize(std::istream &is) { // Clear everything clear(); // Deserialize int version = readU8(is); if(version != 0) throw SerializationError("unsupported ItemDefManager version"); u16 count = readU16(is); for(u16 i=0; i<count; i++) { // Deserialize a string and grab an ItemDefinition from it std::istringstream tmp_is(deSerializeString(is), std::ios::binary); ItemDefinition def; def.deSerialize(tmp_is); // Register registerItem(def); } u16 num_aliases = readU16(is); for(u16 i=0; i<num_aliases; i++) { std::string name = deSerializeString(is); std::string convert_to = deSerializeString(is); registerAlias(name, convert_to); } }
void libvisio::VSDMetaData::readPropertySetStream(librevenge::RVNGInputStream *input) { // ByteOrder input->seek(2, librevenge::RVNG_SEEK_CUR); // Version input->seek(2, librevenge::RVNG_SEEK_CUR); // SystemIdentifier input->seek(4, librevenge::RVNG_SEEK_CUR); // CLSID input->seek(16, librevenge::RVNG_SEEK_CUR); // NumPropertySets input->seek(4, librevenge::RVNG_SEEK_CUR); // FMTID0 //input->seek(16, librevenge::RVNG_SEEK_CUR); uint32_t data1 = readU32(input); uint16_t data2 = readU16(input); uint16_t data3 = readU16(input); uint8_t data4[8]; for (int i = 0; i < 8; i++) { data4[i] = readU8(input); } char FMTID0[36]; sprintf(FMTID0, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", data1, data2, data3, data4[0], data4[1], data4[2], data4[3], data4[4], data4[5], data4[6], data4[7]); uint32_t offset0 = readU32(input); readPropertySet(input, offset0, FMTID0); }
void ObjectProperties::deSerialize(std::istream &is) { int version = readU8(is); if(version != 1) throw SerializationError( "unsupported ObjectProperties version"); hp_max = readS16(is); physical = readU8(is); weight = readF1000(is); collisionbox.MinEdge = readV3F1000(is); collisionbox.MaxEdge = readV3F1000(is); visual = deSerializeString(is); meshfile = deSerializeString(is); visual_size = readV2F1000(is); textures.clear(); u32 texture_count = readU16(is); for(u32 i=0; i<texture_count; i++){ textures.push_back(deSerializeString(is)); } textures_3d.clear(); u32 texture_3d_count = readU16(is); for(u32 i=0; i<texture_3d_count; i++){ textures_3d.push_back(deSerializeString(is)); } spritediv = readV2S16(is); initial_sprite_basepos = readV2S16(is); is_visible = readU8(is); makes_footstep_sound = readU8(is); try{ automatic_rotate = readF1000(is); }catch(SerializationError &e){} }
void libvisio::VSDMetaData::readPropertySetStream(librevenge::RVNGInputStream *input) { // ByteOrder input->seek(2, librevenge::RVNG_SEEK_CUR); // Version input->seek(2, librevenge::RVNG_SEEK_CUR); // SystemIdentifier input->seek(4, librevenge::RVNG_SEEK_CUR); // CLSID input->seek(16, librevenge::RVNG_SEEK_CUR); // NumPropertySets input->seek(4, librevenge::RVNG_SEEK_CUR); // FMTID0 //input->seek(16, librevenge::RVNG_SEEK_CUR); uint32_t data1 = readU32(input); uint16_t data2 = readU16(input); uint16_t data3 = readU16(input); uint8_t data4[8]; for (unsigned char &i : data4) { i = readU8(input); } // Pretty-printed GUID is 36 bytes + the terminating null-character. char FMTID0[37]; sprintf(FMTID0, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", data1, data2, data3, data4[0], data4[1], data4[2], data4[3], data4[4], data4[5], data4[6], data4[7]); uint32_t offset0 = readU32(input); readPropertySet(input, offset0, FMTID0); }
void WP6GraphicsFilenamePacket::_readContents(librevenge::RVNGInputStream *input, WPXEncryption *encryption) { if ((m_flags & 0x01) == 0x00) return; unsigned short tmpNumChildIds = readU16(input, encryption); for (unsigned short i = 0; i < tmpNumChildIds; i++) m_childIds.push_back(readU16(input, encryption)); }
void FlcPlayer::decodeVideo(bool skipLastFrame) { bool videoFrameFound = false; while (!videoFrameFound) { if (!isValidFrame(_videoFrameData, _videoFrameSize, _videoFrameType)) { _playingState = FINISHED; break; } switch (_videoFrameType) { case FRAME_TYPE: Uint32 delay; readU16(_frameChunks, _videoFrameData + 6); readU16(_delayOverride, _videoFrameData + 8); if (_headerType == FLI_TYPE) { delay = _delayOverride > 0 ? _delayOverride : _headerSpeed * (1000.0 / 70.0); } else { delay = _videoDelay; } waitForNextFrame(delay); // Skip the frame header, we are not interested in the rest _chunkData = _videoFrameData + 16; _videoFrameData += _videoFrameSize; // If this frame is the last one, don't play it if(isEndOfFile(_videoFrameData)) _playingState = FINISHED; if(!shouldQuit() || !skipLastFrame) playVideoFrame(); videoFrameFound = true; break; case AUDIO_CHUNK: _videoFrameData += _videoFrameSize + 16; break; case PREFIX_CHUNK: // Just skip it _videoFrameData += _videoFrameSize; break; } } }
void NodeTimerList::deSerialize(std::istream &is, u8 map_format_version) { m_data.clear(); if(map_format_version == 24){ u8 timer_version = readU8(is); if(timer_version == 0) return; if(timer_version != 1) throw SerializationError("unsupported NodeTimerList version"); } if(map_format_version >= 25){ u8 timer_data_len = readU8(is); if(timer_data_len != 2+4+4) throw SerializationError("unsupported NodeTimer data length"); } u16 count = readU16(is); for(u16 i=0; i<count; i++) { u16 p16 = readU16(is); v3s16 p; p.Z = p16 / MAP_BLOCKSIZE / MAP_BLOCKSIZE; p16 &= MAP_BLOCKSIZE * MAP_BLOCKSIZE - 1; p.Y = p16 / MAP_BLOCKSIZE; p16 &= MAP_BLOCKSIZE - 1; p.X = p16; NodeTimer t; t.deSerialize(is); if(t.timeout <= 0) { infostream<<"WARNING: NodeTimerList::deSerialize(): " <<"invalid data at position" <<"("<<p.X<<","<<p.Y<<","<<p.Z<<"): Ignoring." <<std::endl; continue; } if(m_data.find(p) != m_data.end()) { infostream<<"WARNING: NodeTimerList::deSerialize(): " <<"already set data at position" <<"("<<p.X<<","<<p.Y<<","<<p.Z<<"): Ignoring." <<std::endl; continue; } m_data.insert(std::make_pair(p, t)); } }
void TileDef::deSerialize(std::istream &is) { int version = readU8(is); 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); }
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); }
void STTBF::init( U16 lid, OLEStreamReader* reader, const U8* ptr ) { bool extended = false; U16 count = readU16( reader, &ptr ); // "extended" characters? if ( count == 0xffff ) { extended = true; // read the real size count = readU16( reader, &ptr ); } m_extraDataLength = readU16( reader, &ptr ); // If we don't read unicode strings we have to set up a text converter TextConverter* textconverter = 0; if ( !extended ) textconverter = new TextConverter( lid ); // read one string after the other for ( U16 i = 0; i < count; ++i ) { U16 len = 0; if ( extended ) // double byte count! len = readU16( reader, &ptr ); else len = readU8( reader, &ptr ); if ( len != 0 ) { if ( extended ) { XCHAR* string = new XCHAR[ len ]; for ( U16 j = 0; j < len; ++j ) string[ j ] = readU16( reader, &ptr ); UString ustring( reinterpret_cast<const wvWare::UChar *>( string ), len ); delete [] string; m_strings.push_back( ustring ); } else { U8* string = new U8[ len ]; read( reader, &ptr, string, len ); UString ustring( textconverter->convert( reinterpret_cast<char*>( string ), static_cast<unsigned int>( len ) ) ); delete [] string; m_strings.push_back( ustring ); } } else m_strings.push_back( UString("") ); if ( m_extraDataLength != 0 ) { U8* extra = new U8[ m_extraDataLength ]; read( reader, &ptr, extra, m_extraDataLength ); m_extraData.push_back( extra ); } } delete textconverter; }
void CraftDefinitionShaped::deSerializeBody(std::istream &is, int version) { if(version != 1) throw SerializationError( "unsupported CraftDefinitionShaped version"); output = deSerializeString(is); width = readU16(is); recipe.clear(); u32 count = readU16(is); for(u32 i=0; i<count; i++) recipe.push_back(deSerializeString(is)); replacements.deSerialize(is); }
void FlcPlayer::fliLC() { Uint8 *pSrc, *pDst, *pTmpDst; Sint8 countData; Uint8 countSkip; Uint8 fill; Uint16 lines, tmp; int packetsCount; pSrc = _chunkData + 6; pDst = (Uint8*)_mainScreen->pixels + _offset; readU16(tmp, pSrc); pSrc += 2; pDst += tmp*_mainScreen->pitch; readU16(lines, pSrc); pSrc += 2; while (lines--) { pTmpDst = pDst; packetsCount = *(pSrc++); while (packetsCount--) { countSkip = *(pSrc++); pTmpDst += countSkip; countData = *(pSrc++); if (countData > 0) { while (countData--) { *(pTmpDst++) = *(pSrc++); } } else { if (countData < 0) { countData = -countData; fill = *(pSrc++); while (countData--) { *(pTmpDst++) = fill; } } } } pDst += _mainScreen->pitch; } }
bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic) { const size_t kUsWeightClassOffset = 4; const size_t kFsSelectionOffset = 62; const uint16_t kItalicFlag = (1 << 0); if (os2_size < kFsSelectionOffset + 2) { return false; } uint16_t weightClass = readU16(os2_data, kUsWeightClassOffset); *weight = weightClass / 100; uint16_t fsSelection = readU16(os2_data, kFsSelectionOffset); *italic = (fsSelection & kItalicFlag) != 0; return true; }
void NodeMetadataList::deSerialize(std::istream &is) { { JMutexAutoLock lock(m_mutex); m_data.clear(); } u8 buf[6]; is.read((char*)buf, 2); u16 version = readU16(buf); if (version > 1) { infostream<<__FUNCTION_NAME<<": version "<<version<<" not supported" <<std::endl; throw SerializationError("NodeMetadataList::deSerialize"); } is.read((char*)buf, 2); u16 count = readU16(buf); for (u16 i=0; i<count; i++) { is.read((char*)buf, 2); u16 p16 = readU16(buf); v3s16 p(0,0,0); p.Z += p16 / MAP_BLOCKSIZE / MAP_BLOCKSIZE; p16 -= p.Z * MAP_BLOCKSIZE * MAP_BLOCKSIZE; p.Y += p16 / MAP_BLOCKSIZE; p16 -= p.Y * MAP_BLOCKSIZE; p.X += p16; NodeMetadata *data = NodeMetadata::deSerialize(is); if (data == NULL) continue; if (m_data.find(p)) { infostream<<"WARNING: NodeMetadataList::deSerialize(): " <<"already set data at position" <<"("<<p.X<<","<<p.Y<<","<<p.Z<<"): Ignoring." <<std::endl; delete data; continue; } m_data.insert(p, data); } }
void NameIdMapping::deSerialize(std::istream &is) { int version = readU8(is); if(version != 0) throw SerializationError("unsupported NameIdMapping version"); u32 count = readU16(is); m_id_to_name.clear(); m_name_to_id.clear(); for(u32 i=0; i<count; i++){ u16 id = readU16(is); std::string name = deSerializeString(is); m_id_to_name[id] = name; m_name_to_id[name] = id; } }
void CNodeDefManager::deSerialize(std::istream &is) { clear(); int version = readU8(is); if (version != 1) throw SerializationError("unsupported NodeDefinitionManager version"); u16 count = readU16(is); std::istringstream is2(deSerializeLongString(is), std::ios::binary); ContentFeatures f; for (u16 n = 0; n < count; n++) { u16 i = readU16(is2); // Read it from the string wrapper std::string wrapper = deSerializeString(is2); std::istringstream wrapper_is(wrapper, std::ios::binary); f.deSerialize(wrapper_is); // Check error conditions if (i == CONTENT_IGNORE || i == CONTENT_AIR || i == CONTENT_UNKNOWN) { warningstream << "NodeDefManager::deSerialize(): " "not changing builtin node " << i << std::endl; continue; } if (f.name.empty()) { warningstream << "NodeDefManager::deSerialize(): " "received empty name" << std::endl; continue; } // Ignore aliases u16 existing_id; if (m_name_id_mapping.getId(f.name, existing_id) && i != existing_id) { warningstream << "NodeDefManager::deSerialize(): " "already defined with different ID: " << f.name << std::endl; continue; } // All is ok, add node definition with the requested ID if (i >= m_content_features.size()) m_content_features.resize((u32)(i) + 1); m_content_features[i] = f; addNameIdMapping(i, f.name); verbosestream << "deserialized " << f.name << std::endl; getNodeBoxUnion(f.selection_box, f, &m_selection_box_union); fixSelectionBoxIntUnion(); } }
void TileDef::deSerialize(std::istream &is, u8 contentfeatures_version, NodeDrawType drawtype) { int version = readU8(is); if (version < 6) throw SerializationError("unsupported TileDef version"); name = deSerializeString(is); animation.deSerialize(is, version); u16 flags = readU16(is); backface_culling = flags & TILE_FLAG_BACKFACE_CULLING; tileable_horizontal = flags & TILE_FLAG_TILEABLE_HORIZONTAL; tileable_vertical = flags & TILE_FLAG_TILEABLE_VERTICAL; has_color = flags & TILE_FLAG_HAS_COLOR; bool has_scale = flags & TILE_FLAG_HAS_SCALE; bool has_align_style = flags & TILE_FLAG_HAS_ALIGN_STYLE; if (has_color) { color.setRed(readU8(is)); color.setGreen(readU8(is)); color.setBlue(readU8(is)); } scale = has_scale ? readU8(is) : 0; if (has_align_style) align_style = static_cast<AlignStyle>(readU8(is)); else align_style = ALIGN_STYLE_NODE; }
void ContentFeatures::deSerialize(std::istream &is) { int version = readU8(is); if(version != 5) throw SerializationError("unsupported ContentFeatures version"); name = deSerializeString(is); groups.clear(); u32 groups_size = readU16(is); for(u32 i=0; i<groups_size; i++){ std::string name = deSerializeString(is); int value = readS16(is); groups[name] = value; } drawtype = (enum NodeDrawType)readU8(is); visual_scale = readF1000(is); if(readU8(is) != 6) throw SerializationError("unsupported tile count"); for(u32 i=0; i<6; i++) tiledef[i].deSerialize(is); if(readU8(is) != CF_SPECIAL_COUNT) throw SerializationError("unsupported CF_SPECIAL_COUNT"); for(u32 i=0; i<CF_SPECIAL_COUNT; i++) tiledef_special[i].deSerialize(is); alpha = readU8(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)); param_type = (enum ContentParamType)readU8(is); param_type_2 = (enum ContentParamType2)readU8(is); is_ground_content = readU8(is); light_propagates = readU8(is); sunlight_propagates = readU8(is); walkable = readU8(is); pointable = readU8(is); diggable = readU8(is); climbable = readU8(is); buildable_to = readU8(is); deSerializeString(is); // legacy: used to be metadata_name liquid_type = (enum LiquidType)readU8(is); liquid_alternative_flowing = deSerializeString(is); liquid_alternative_source = deSerializeString(is); liquid_viscosity = readU8(is); light_source = readU8(is); damage_per_second = readU32(is); node_box.deSerialize(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); // 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 liquid_renewable = readU8(is); }catch(SerializationError &e) {}; }
/* Parse voice header chunk. */ status IFFFile::parseVHDR(const Tag &type, size_t size) { assert(type == "VHDR"); Track *track = getTrack(); uint32_t oneShotSamples, repeatSamples, samplesPerRepeat; uint16_t sampleRate; uint8_t octaves, compression; uint32_t volume; readU32(&oneShotSamples); readU32(&repeatSamples); readU32(&samplesPerRepeat); readU16(&sampleRate); readU8(&octaves); readU8(&compression); readU32(&volume); track->f.sampleWidth = 8; track->f.sampleRate = sampleRate; track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP; track->f.compressionType = AF_COMPRESSION_NONE; track->f.byteOrder = AF_BYTEORDER_BIGENDIAN; track->f.channelCount = 1; track->f.framesPerPacket = 1; track->f.computeBytesPerPacketPCM(); _af_set_sample_format(&track->f, track->f.sampleFormat, track->f.sampleWidth); return AF_SUCCEED; }
void FlcPlayer::color64() { Uint8 *pSrc; Uint16 NumColors, NumColorPackets; Uint8 NumColorsSkip; pSrc = _chunkData + 6; readU16(NumColorPackets, pSrc); pSrc += 2; while (NumColorPackets--) { NumColorsSkip = *(pSrc++); NumColors = *(pSrc++); if (NumColors == 0) { NumColors = 256; } for (int i = 0; i < NumColors; ++i) { _colors[i].r = *(pSrc++) << 2; _colors[i].g = *(pSrc++) << 2; _colors[i].b = *(pSrc++) << 2; } _realScreen->setPalette(_colors, NumColorsSkip, NumColors, true); } }
void FlcPlayer::color256() { Uint8 *pSrc; Uint16 numColorPackets; Uint16 numColors = 0; Uint8 numColorsSkip; pSrc = _chunkData + 6; readU16(numColorPackets, pSrc); pSrc += 2; while (numColorPackets--) { numColorsSkip = *(pSrc++) + numColors; numColors = *(pSrc++); if (numColors == 0) { numColors = 256; } for (int i = 0; i < numColors; ++i) { _colors[i].r = *(pSrc++); _colors[i].g = *(pSrc++); _colors[i].b = *(pSrc++); } _realScreen->setPalette(_colors, numColorsSkip, numColors, true); if (numColorPackets >= 1) { ++numColors; } } }
void FlcPlayer::decodeAudio(int frames) { int audioFramesFound = 0; while (audioFramesFound < frames && !isEndOfFile(_audioFrameData)) { if (!isValidFrame(_audioFrameData, _audioFrameSize, _audioFrameType)) { _playingState = FINISHED; break; } switch (_audioFrameType) { case FRAME_TYPE: case PREFIX_CHUNK: _audioFrameData += _audioFrameSize; break; case AUDIO_CHUNK: Uint16 sampleRate; readU16(sampleRate, _audioFrameData + 8); _chunkData = _audioFrameData + 16; playAudioFrame(sampleRate); _audioFrameData += _audioFrameSize + 16; ++audioFramesFound; break; } } }
void ClientMediaDownloader::deSerializeHashSet(const std::string &data, std::set<std::string> &result) { if (data.size() < 6 || data.size() % 20 != 6) { throw SerializationError( "ClientMediaDownloader::deSerializeHashSet: " "invalid hash set file size"); } const u8 *data_cstr = (const u8*) data.c_str(); u32 signature = readU32(&data_cstr[0]); if (signature != MTHASHSET_FILE_SIGNATURE) { throw SerializationError( "ClientMediaDownloader::deSerializeHashSet: " "invalid hash set file signature"); } u16 version = readU16(&data_cstr[4]); if (version != 1) { throw SerializationError( "ClientMediaDownloader::deSerializeHashSet: " "unsupported hash set file version"); } for (u32 pos = 6; pos < data.size(); pos += 20) { result.insert(data.substr(pos, 20)); } }
void ItemDefinition::deSerialize(std::istream &is) { // Reset everything reset(); // Deserialize int version = readU8(is); if(version != 1) throw SerializationError("unsupported ItemDefinition version"); type = (enum ItemType)readU8(is); name = deSerializeString(is); description = deSerializeString(is); inventory_image = deSerializeString(is); wield_image = deSerializeString(is); wield_scale = readV3F1000(is); stack_max = readS16(is); usable = readU8(is); liquids_pointable = readU8(is); eatable = readU8(is); std::string tool_capabilities_s = deSerializeString(is); 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++){ std::string name = deSerializeString(is); int value = readS16(is); groups[name] = value; } }
void NodeBox::deSerialize(std::istream &is) { int version = readU8(is); if(version < 1 || version > 2) throw SerializationError("unsupported NodeBox version"); reset(); type = (enum NodeBoxType)readU8(is); if(type == NODEBOX_FIXED || type == NODEBOX_LEVELED) { u16 fixed_count = readU16(is); while(fixed_count--) { aabb3f box; box.MinEdge = readV3F1000(is); box.MaxEdge = readV3F1000(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); } }
bool FlcPlayer::isValidFrame(Uint8 *frameHeader, Uint32 &frameSize, Uint16 &frameType) { readU32(frameSize, frameHeader); readU16(frameType, frameHeader + 4); return (frameType == FRAME_TYPE || frameType == AUDIO_CHUNK || frameType == PREFIX_CHUNK); }