void World::loadPakList(std::string&& fname, std::vector<PakArray> &paklist) { VFS::IStreamPtr stream = VFS::Manager::get().open(fname.c_str()); if(!stream) throw std::runtime_error("Failed to open "+fname); size_t rownum = 0; std::map<size_t,size_t> offsets_rows; offsets_rows[VFS::read_le32(*stream)] = rownum++; while((size_t)stream->tellg() < offsets_rows.begin()->first) offsets_rows[VFS::read_le32(*stream)] = rownum++; auto iter = offsets_rows.begin(); while(iter != offsets_rows.end()) { auto next = std::next(iter); PakArray pak; while((next != offsets_rows.end() && (size_t)stream->tellg() < next->first) || (next == offsets_rows.end() && stream->peek() != std::istream::traits_type::eof())) { uint16_t count = VFS::read_le16(*stream); uint8_t val = stream->get(); pak.push_back(std::make_pair(count, val)); } if(iter->second >= paklist.size()) paklist.resize(iter->second+1); paklist[iter->second] = std::move(pak); iter = next; } }
void TextureManager::initialize() { VFS::IStreamPtr stream = VFS::Manager::get().open("PAL.PAL"); std::streamsize len = 0; if(stream && stream->seekg(0, std::ios_base::end)) { len = stream->tellg(); stream->seekg(0); } if(len == 776) { len -= 8; stream->ignore(8); } if(len != sizeof(mCurrentPalette)) throw std::runtime_error("Invalid palette size (expected 768 or 776 bytes)"); stream->read(reinterpret_cast<char*>(mCurrentPalette.data()), sizeof(mCurrentPalette)); }
DFAFile::DFAFile(const std::string &filename, const Palette &palette) : pixels() { VFS::IStreamPtr stream = VFS::Manager::get().open(filename.c_str()); Debug::check(stream != nullptr, "DFAFile", "Could not open \"" + filename + "\"."); stream->seekg(0, std::ios::end); const auto fileSize = stream->tellg(); stream->seekg(0, std::ios::beg); std::vector<uint8_t> srcData(fileSize); stream->read(reinterpret_cast<char*>(srcData.data()), srcData.size()); // Read DFA header data. const uint16_t imageCount = Bytes::getLE16(srcData.data()); const uint16_t unknown1 = Bytes::getLE16(srcData.data() + 2); const uint16_t unknown2 = Bytes::getLE16(srcData.data() + 4); const uint16_t width = Bytes::getLE16(srcData.data() + 6); const uint16_t height = Bytes::getLE16(srcData.data() + 8); const uint16_t compressedLength = Bytes::getLE16(srcData.data() + 10); // First frame. // Frame data with palette indices. std::vector<std::vector<uint8_t>> frames; // Uncompress the initial frame. frames.push_back(std::vector<uint8_t>(width * height)); Compression::decodeRLE(srcData.data() + 12, width * height, frames.at(0)); // Make copies of the original frame for each update chunk. for (int i = 1; i < imageCount; ++i) { frames.push_back(frames.at(0)); } // Offset to the beginning of the chunk data; advances as the chunk data is read. uint32_t offset = 12 + compressedLength; // Start reading chunks for each update group. Skip the first frame because // that's the full image. for (uint32_t frameIndex = 1; frameIndex < imageCount; ++frameIndex) { // Select the frame buffer at the current frame index. std::vector<uint8_t> &frame = frames.at(frameIndex); // Pointer to the beginning of the chunk data. Each update chunk // changes a group of pixels in a copy of the original image. const uint8_t *chunkData = srcData.data() + offset; const uint16_t chunkSize = Bytes::getLE16(chunkData); const uint16_t chunkCount = Bytes::getLE16(chunkData + 2); // Move the offset past the chunk header. offset += 4; for (uint32_t chunkIndex = 0; chunkIndex < chunkCount; ++chunkIndex) { const uint8_t *updateData = srcData.data() + offset; const uint16_t updateOffset = Bytes::getLE16(updateData); const uint16_t updateCount = Bytes::getLE16(updateData + 2); // Move the offset past the update header. offset += 4; for (uint32_t i = 0; i < updateCount; ++i) { frame.at(updateOffset + i) = *(srcData.begin() + offset); offset++; } } } this->width = width; this->height = height; // Finally, create 32-bit images using each frame's palette indices. for (const auto &frame : frames) { this->pixels.push_back(std::unique_ptr<uint32_t>( new uint32_t[this->width * this->height])); uint32_t *dstPixels = this->pixels.at(this->pixels.size() - 1).get(); std::transform(frame.begin(), frame.begin() + frame.size(), dstPixels, [&palette](uint8_t col) -> uint32_t { return palette[col].toARGB(); }); } }
void World::initialize(osgViewer::Viewer *viewer, osg::Group *sceneroot) { std::set<std::string> names = VFS::Manager::get().list("MAPNAMES.[0-9]*"); if(names.empty()) throw std::runtime_error("Failed to find any regions"); VFS::IStreamPtr stream; for(const std::string &name : names) { size_t pos = name.rfind('.'); if(pos == std::string::npos) continue; std::string regstr = name.substr(pos+1); unsigned long regnum = std::stoul(regstr, nullptr, 10); /* Get names */ stream = VFS::Manager::get().open(name.c_str()); if(!stream) throw std::runtime_error("Failed to open "+name); uint32_t mapcount = VFS::read_le32(*stream); if(mapcount == 0) continue; MapRegion region; region.mNames.resize(mapcount); for(std::string &mapname : region.mNames) { char mname[32]; if(!stream->read(mname, sizeof(mname)) || stream->gcount() != sizeof(mname)) throw std::runtime_error("Failed to read map names from "+name); mapname.assign(mname, sizeof(mname)); size_t end = mapname.find('\0'); if(end != std::string::npos) mapname.resize(end); } stream = nullptr; /* Get table data */ std::string fname = "MAPTABLE."+regstr; stream = VFS::Manager::get().open(fname.c_str()); if(!stream) throw std::runtime_error("Failed to open "+fname); region.mTable.resize(region.mNames.size()); for(MapTable &maptable : region.mTable) { maptable.mMapId = VFS::read_le32(*stream); maptable.mUnknown1 = stream->get(); maptable.mLongitudeType = VFS::read_le32(*stream); maptable.mLatitude = VFS::read_le16(*stream); maptable.mUnknown2 = VFS::read_le16(*stream); maptable.mUnknown3 = VFS::read_le32(*stream); } stream = nullptr; /* Get exterior data */ fname = "MAPPITEM."+regstr; stream = VFS::Manager::get().open(fname.c_str()); if(!stream) throw std::runtime_error("Failed to open "+fname); std::vector<uint32_t> extoffsets(region.mNames.size()); for(uint32_t &offset : extoffsets) offset = VFS::read_le32(*stream); std::streamoff extbase_offset = stream->tellg(); uint32_t *extoffset = extoffsets.data(); region.mExteriors.resize(extoffsets.size()); for(ExteriorLocation &extinfo : region.mExteriors) { stream->seekg(extbase_offset + *extoffset); extinfo.load(*stream); ++extoffset; } stream = nullptr; /* Get dungeon data */ fname = "MAPDITEM."+regstr; stream = VFS::Manager::get().open(fname.c_str()); if(!stream) throw std::runtime_error("Failed to open "+fname); DungeonHeader dheader; dheader.load(*stream); std::streamoff dbase_offset = stream->tellg(); DungeonHeader::Offset *doffset = dheader.mOffsets.data(); region.mDungeons.resize(dheader.mDungeonCount); for(DungeonInterior &dinfo : region.mDungeons) { stream->seekg(dbase_offset + doffset->mOffset); dinfo.load(*stream); if(dinfo.mExteriorLocationId != doffset->mExteriorLocationId) throw std::runtime_error("Dungeon exterior location id mismatch for "+std::string(dinfo.mLocationName)+": "+ std::to_string(dinfo.mExteriorLocationId)+" / "+std::to_string(doffset->mExteriorLocationId)); ++doffset; } stream = nullptr; if(regnum >= mRegions.size()) mRegions.resize(regnum+1); mRegions[regnum] = std::move(region); } loadPakList("CLIMATE.PAK", mClimates); loadPakList("POLITIC.PAK", mPolitics); mViewer = viewer; mSceneRoot = sceneroot; }