Xargon/Duckstation
1
0
Fork 0
mirror of https://github.com/RetroDECK/Duckstation.git synced 2024-11-22 22:05:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Qt: Fix 'Edit Memory Cards' using disc-specific cards

Browse source
This commit is contained in:
Stenzek 2023-11-28 14:54:25 +10:00
parent e382f2b64a
commit c482dfd27a
No known key found for this signature in database
4 changed files with 60 additions and 17 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

47
src/core/game_list.cpp
View file

@ -40,7 +40,7 @@ namespace {
enum : u32
{
GAME_LIST_CACHE_SIGNATURE = 0x45434C47,
GAME_LIST_CACHE_SIGNATURE = 0x45434C48,
GAME_LIST_CACHE_VERSION = 34,
PLAYED_TIME_SERIAL_LENGTH = 32,
@ -232,6 +232,19 @@ bool GameList::GetDiscListEntry(const std::string& path, Entry* entry)
entry->max_blocks = dentry->max_blocks;
entry->supported_controllers = dentry->supported_controllers;
entry->compatibility = dentry->compatibility;
if (!cdi->HasSubImages())
{
for (size_t i = 0; i < dentry->disc_set_serials.size(); i++)
{
if (dentry->disc_set_serials[i] == entry->serial)
{
entry->disc_set_name = dentry->disc_set_name;
entry->disc_set_index = static_cast<s8>(i);
break;
}
}
}
}
else
{
@ -318,12 +331,13 @@ bool GameList::LoadEntriesFromCache(ByteStream* stream)
if (!stream->ReadU8(&type) || !stream->ReadU8(&region) || !stream->ReadSizePrefixedString(&path) ||
!stream->ReadSizePrefixedString(&ge.serial) || !stream->ReadSizePrefixedString(&ge.title) ||
!stream->ReadSizePrefixedString(&ge.genre) || !stream->ReadSizePrefixedString(&ge.publisher) ||
!stream->ReadSizePrefixedString(&ge.developer) || !stream->ReadU64(&ge.hash) ||
!stream->ReadU64(&ge.total_size) || !stream->ReadU64(reinterpret_cast<u64*>(&ge.last_modified_time)) ||
!stream->ReadU64(&ge.release_date) || !stream->ReadU16(&ge.supported_controllers) ||
!stream->ReadU8(&ge.min_players) || !stream->ReadU8(&ge.max_players) || !stream->ReadU8(&ge.min_blocks) ||
!stream->ReadU8(&ge.max_blocks) || !stream->ReadU8(&compatibility_rating) ||
!stream->ReadSizePrefixedString(&ge.disc_set_name) || !stream->ReadSizePrefixedString(&ge.genre) ||
!stream->ReadSizePrefixedString(&ge.publisher) || !stream->ReadSizePrefixedString(&ge.developer) ||
!stream->ReadU64(&ge.hash) || !stream->ReadU64(&ge.total_size) ||
!stream->ReadU64(reinterpret_cast<u64*>(&ge.last_modified_time)) || !stream->ReadU64(&ge.release_date) ||
!stream->ReadU16(&ge.supported_controllers) || !stream->ReadU8(&ge.min_players) ||
!stream->ReadU8(&ge.max_players) || !stream->ReadU8(&ge.min_blocks) || !stream->ReadU8(&ge.max_blocks) ||
!stream->ReadS8(&ge.disc_set_index) || !stream->ReadU8(&compatibility_rating) ||
region >= static_cast<u8>(DiscRegion::Count) || type >= static_cast<u8>(EntryType::Count) ||
compatibility_rating >= static_cast<u8>(GameDatabase::CompatibilityRating::Count))
{
@ -354,6 +368,7 @@ bool GameList::WriteEntryToCache(const Entry* entry)
result &= s_cache_write_stream->WriteSizePrefixedString(entry->path);
result &= s_cache_write_stream->WriteSizePrefixedString(entry->serial);
result &= s_cache_write_stream->WriteSizePrefixedString(entry->title);
result &= s_cache_write_stream->WriteSizePrefixedString(entry->disc_set_name);
result &= s_cache_write_stream->WriteSizePrefixedString(entry->genre);
result &= s_cache_write_stream->WriteSizePrefixedString(entry->publisher);
result &= s_cache_write_stream->WriteSizePrefixedString(entry->developer);
@ -366,6 +381,7 @@ bool GameList::WriteEntryToCache(const Entry* entry)
result &= s_cache_write_stream->WriteU8(entry->max_players);
result &= s_cache_write_stream->WriteU8(entry->min_blocks);
result &= s_cache_write_stream->WriteU8(entry->max_blocks);
result &= s_cache_write_stream->WriteS8(entry->disc_set_index);
result &= s_cache_write_stream->WriteU8(static_cast<u8>(entry->compatibility));
return result;
}
@ -581,7 +597,7 @@ const GameList::Entry* GameList::GetEntryForPath(const char* path)
return nullptr;
}
const GameList::Entry* GameList::GetEntryBySerial(const std::string_view& serial)
const GameList::Entry* GameList::GetEntryBySerial(std::string_view serial)
{
for (const Entry& entry : s_entries)
{
@ -595,7 +611,7 @@ const GameList::Entry* GameList::GetEntryBySerial(const std::string_view& serial
return nullptr;
}
const GameList::Entry* GameList::GetEntryBySerialAndHash(const std::string_view& serial, u64 hash)
const GameList::Entry* GameList::GetEntryBySerialAndHash(std::string_view serial, u64 hash)
{
for (const Entry& entry : s_entries)
{
@ -606,6 +622,19 @@ const GameList::Entry* GameList::GetEntryBySerialAndHash(const std::string_view&
return nullptr;
}
std::vector<const GameList::Entry*> GameList::GetDiscSetMembers(std::string_view disc_set_name)
{
std::vector<const Entry*> ret;
for (const Entry& entry : s_entries)
{
if (/*!entry.disc_set_member || */ disc_set_name != entry.disc_set_name)
continue;
ret.push_back(&entry);
}
return ret;
}
u32 GameList::GetEntryCount()
{
return static_cast<u32>(s_entries.size());

7
src/core/game_list.h
View file

@ -39,6 +39,7 @@ struct Entry
std::string path;
std::string serial;
std::string title;
std::string disc_set_name;
std::string genre;
std::string publisher;
std::string developer;
@ -54,6 +55,7 @@ struct Entry
u8 max_players = 1;
u8 min_blocks = 0;
u8 max_blocks = 0;
s8 disc_set_index = -1;
GameDatabase::CompatibilityRating compatibility = GameDatabase::CompatibilityRating::Unknown;
@ -75,8 +77,9 @@ bool PopulateEntryFromPath(const std::string& path, Entry* entry);
std::unique_lock<std::recursive_mutex> GetLock();
const Entry* GetEntryByIndex(u32 index);
const Entry* GetEntryForPath(const char* path);
const Entry* GetEntryBySerial(const std::string_view& serial);
const Entry* GetEntryBySerialAndHash(const std::string_view& serial, u64 hash);
const Entry* GetEntryBySerial(std::string_view serial);
const Entry* GetEntryBySerialAndHash(std::string_view serial, u64 hash);
std::vector<const Entry*> GetDiscSetMembers(std::string_view disc_set_name);
u32 GetEntryCount();
bool IsGameListLoaded();

7
src/core/memory_card_image.cpp
View file

@ -229,6 +229,9 @@ u32 MemoryCardImage::GetFreeBlockCount(const DataArray& data)
std::vector<MemoryCardImage::FileInfo> MemoryCardImage::EnumerateFiles(const DataArray& data, bool include_deleted)
{
// For getting the icon, we only consider binary transparency. Some games set the alpha to 0.
static constexpr auto icon_to_rgba8 = [](u16 col) { return (col == 0) ? 0u : VRAMRGBA5551ToRGBA8888(col | 0x8000); };
std::vector<FileInfo> files;
for (u32 dir_frame = 1; dir_frame < FRAMES_PER_BLOCK; dir_frame++)
@ -295,8 +298,8 @@ std::vector<MemoryCardImage::FileInfo> MemoryCardImage::EnumerateFiles(const Dat
u32* pixels_ptr = fi.icon_frames[icon_frame].pixels;
for (u32 i = 0; i < ICON_WIDTH * ICON_HEIGHT; i += 2)
{
*(pixels_ptr++) = VRAMRGBA5551ToRGBA8888(tf->icon_palette[*indices_ptr & 0xF]);
*(pixels_ptr++) = VRAMRGBA5551ToRGBA8888(tf->icon_palette[*indices_ptr >> 4]);
*(pixels_ptr++) = icon_to_rgba8(tf->icon_palette[*indices_ptr & 0xF]);
*(pixels_ptr++) = icon_to_rgba8(tf->icon_palette[*indices_ptr >> 4]);
indices_ptr++;
}
}

14
src/duckstation-qt/mainwindow.cpp
View file

@ -822,17 +822,25 @@ void MainWindow::populateGameListContextMenu(const GameList::Entry* entry, QWidg
}
break;
case MemoryCardType::PerGame:
paths[i] = QString::fromStdString(g_settings.GetGameMemoryCardPath(entry->serial.c_str(), i));
paths[i] = QString::fromStdString(g_settings.GetGameMemoryCardPath(entry->serial, i));
break;
case MemoryCardType::PerGameTitle:
{
paths[i] = QString::fromStdString(
g_settings.GetGameMemoryCardPath(MemoryCard::SanitizeGameTitleForFileName(entry->title).c_str(), i));
g_settings.GetGameMemoryCardPath(MemoryCard::SanitizeGameTitleForFileName(entry->title), i));
if (!entry->disc_set_name.empty() && g_settings.memory_card_use_playlist_title && !QFile::exists(paths[i]))
{
paths[i] = QString::fromStdString(
g_settings.GetGameMemoryCardPath(MemoryCard::SanitizeGameTitleForFileName(entry->disc_set_name), i));
}
}
break;
case MemoryCardType::PerGameFileTitle:
{
const std::string display_name(FileSystem::GetDisplayNameFromPath(entry->path));
paths[i] = QString::fromStdString(g_settings.GetGameMemoryCardPath(
MemoryCard::SanitizeGameTitleForFileName(Path::GetFileTitle(display_name)).c_str(), i));
MemoryCard::SanitizeGameTitleForFileName(Path::GetFileTitle(display_name)), i));
}
break;
default: