ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #12157 from Dentomologist/texturecachebase_add_m_prefix 

TextureCacheBase: Add m_ prefix to member variables
This commit is contained in:
Admiral H. Curtiss 2023-09-03 03:10:57 +02:00 committed by GitHub
parent bd57d17dee d5d3eb5025
commit 6d04618921
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 117 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

206
Source/Core/VideoCommon/TextureCacheBase.cpp
View File

@ -81,23 +81,23 @@ TCacheEntry::~TCacheEntry()
void TextureCacheBase::CheckTempSize(size_t required_size) void TextureCacheBase::CheckTempSize(size_t required_size)
{ {
if (required_size <= temp_size) if (required_size <= m_temp_size)
return; return;
temp_size = required_size; m_temp_size = required_size;
Common::FreeAlignedMemory(temp); Common::FreeAlignedMemory(m_temp);
temp = static_cast<u8*>(Common::AllocateAlignedMemory(temp_size, 16)); m_temp = static_cast<u8*>(Common::AllocateAlignedMemory(m_temp_size, 16));
} }
TextureCacheBase::TextureCacheBase() TextureCacheBase::TextureCacheBase()
{ {
SetBackupConfig(g_ActiveConfig); SetBackupConfig(g_ActiveConfig);
temp_size = 2048 * 2048 * 4; m_temp_size = 2048 * 2048 * 4;
temp = static_cast<u8*>(Common::AllocateAlignedMemory(temp_size, 16)); m_temp = static_cast<u8*>(Common::AllocateAlignedMemory(m_temp_size, 16));
TexDecoder_SetTexFmtOverlayOptions(backup_config.texfmt_overlay, TexDecoder_SetTexFmtOverlayOptions(m_backup_config.texfmt_overlay,
backup_config.texfmt_overlay_center); m_backup_config.texfmt_overlay_center);
HiresTexture::Init(); HiresTexture::Init();
@ -117,8 +117,8 @@ void TextureCacheBase::Shutdown()
TextureCacheBase::~TextureCacheBase() TextureCacheBase::~TextureCacheBase()
{ {
Common::FreeAlignedMemory(temp); Common::FreeAlignedMemory(m_temp);
temp = nullptr; m_temp = nullptr;
} }
bool TextureCacheBase::Initialize() bool TextureCacheBase::Initialize()
@ -137,18 +137,18 @@ void TextureCacheBase::Invalidate()
FlushEFBCopies(); FlushEFBCopies();
TMEM::InvalidateAll(); TMEM::InvalidateAll();
for (auto& bind : bound_textures) for (auto& bind : m_bound_textures)
bind.reset(); bind.reset();
textures_by_hash.clear(); m_textures_by_hash.clear();
textures_by_address.clear(); m_textures_by_address.clear();
texture_pool.clear(); m_texture_pool.clear();
} }
void TextureCacheBase::OnConfigChanged(const VideoConfig& config) void TextureCacheBase::OnConfigChanged(const VideoConfig& config)
{ {
if (config.bHiresTextures != backup_config.hires_textures || if (config.bHiresTextures != m_backup_config.hires_textures ||
config.bCacheHiresTextures != backup_config.cache_hires_textures) config.bCacheHiresTextures != m_backup_config.cache_hires_textures)
{ {
HiresTexture::Update(); HiresTexture::Update();
} }
@ -157,15 +157,15 @@ void TextureCacheBase::OnConfigChanged(const VideoConfig& config)
config.graphics_mod_config ? config.graphics_mod_config->GetChangeCount() : 0; config.graphics_mod_config ? config.graphics_mod_config->GetChangeCount() : 0;
// TODO: Invalidating texcache is really stupid in some of these cases // TODO: Invalidating texcache is really stupid in some of these cases
if (config.iSafeTextureCache_ColorSamples != backup_config.color_samples || if (config.iSafeTextureCache_ColorSamples != m_backup_config.color_samples ||
config.bTexFmtOverlayEnable != backup_config.texfmt_overlay || config.bTexFmtOverlayEnable != m_backup_config.texfmt_overlay ||
config.bTexFmtOverlayCenter != backup_config.texfmt_overlay_center || config.bTexFmtOverlayCenter != m_backup_config.texfmt_overlay_center ||
config.bHiresTextures != backup_config.hires_textures || config.bHiresTextures != m_backup_config.hires_textures ||
config.bEnableGPUTextureDecoding != backup_config.gpu_texture_decoding || config.bEnableGPUTextureDecoding != m_backup_config.gpu_texture_decoding ||
config.bDisableCopyToVRAM != backup_config.disable_vram_copies || config.bDisableCopyToVRAM != m_backup_config.disable_vram_copies ||
config.bArbitraryMipmapDetection != backup_config.arbitrary_mipmap_detection || config.bArbitraryMipmapDetection != m_backup_config.arbitrary_mipmap_detection ||
config.bGraphicMods != backup_config.graphics_mods || config.bGraphicMods != m_backup_config.graphics_mods ||
change_count != backup_config.graphics_mod_change_count) change_count != m_backup_config.graphics_mod_change_count)
{ {
Invalidate(); Invalidate();
TexDecoder_SetTexFmtOverlayOptions(config.bTexFmtOverlayEnable, config.bTexFmtOverlayCenter); TexDecoder_SetTexFmtOverlayOptions(config.bTexFmtOverlayEnable, config.bTexFmtOverlayCenter);
@ -176,8 +176,8 @@ void TextureCacheBase::OnConfigChanged(const VideoConfig& config)
void TextureCacheBase::Cleanup(int _frameCount) void TextureCacheBase::Cleanup(int _frameCount)
{ {
TexAddrCache::iterator iter = textures_by_address.begin(); TexAddrCache::iterator iter = m_textures_by_address.begin();
TexAddrCache::iterator tcend = textures_by_address.end(); TexAddrCache::iterator tcend = m_textures_by_address.end();
while (iter != tcend) while (iter != tcend)
{ {
if (iter->second->frameCount == FRAMECOUNT_INVALID) if (iter->second->frameCount == FRAMECOUNT_INVALID)
@ -214,8 +214,8 @@ void TextureCacheBase::Cleanup(int _frameCount)
} }
} }
TexPool::iterator iter2 = texture_pool.begin(); TexPool::iterator iter2 = m_texture_pool.begin();
TexPool::iterator tcend2 = texture_pool.end(); TexPool::iterator tcend2 = m_texture_pool.end();
while (iter2 != tcend2) while (iter2 != tcend2)
{ {
if (iter2->second.frameCount == FRAMECOUNT_INVALID) if (iter2->second.frameCount == FRAMECOUNT_INVALID)
@ -224,7 +224,7 @@ void TextureCacheBase::Cleanup(int _frameCount)
} }
if (_frameCount > TEXTURE_POOL_KILL_THRESHOLD + iter2->second.frameCount) if (_frameCount > TEXTURE_POOL_KILL_THRESHOLD + iter2->second.frameCount)
{ {
iter2 = texture_pool.erase(iter2); iter2 = m_texture_pool.erase(iter2);
} }
else else
{ {
@ -246,18 +246,18 @@ bool TCacheEntry::OverlapsMemoryRange(u32 range_address, u32 range_size) const
void TextureCacheBase::SetBackupConfig(const VideoConfig& config) void TextureCacheBase::SetBackupConfig(const VideoConfig& config)
{ {
backup_config.color_samples = config.iSafeTextureCache_ColorSamples; m_backup_config.color_samples = config.iSafeTextureCache_ColorSamples;
backup_config.texfmt_overlay = config.bTexFmtOverlayEnable; m_backup_config.texfmt_overlay = config.bTexFmtOverlayEnable;
backup_config.texfmt_overlay_center = config.bTexFmtOverlayCenter; m_backup_config.texfmt_overlay_center = config.bTexFmtOverlayCenter;
backup_config.hires_textures = config.bHiresTextures; m_backup_config.hires_textures = config.bHiresTextures;
backup_config.cache_hires_textures = config.bCacheHiresTextures; m_backup_config.cache_hires_textures = config.bCacheHiresTextures;
backup_config.stereo_3d = config.stereo_mode != StereoMode::Off; m_backup_config.stereo_3d = config.stereo_mode != StereoMode::Off;
backup_config.efb_mono_depth = config.bStereoEFBMonoDepth; m_backup_config.efb_mono_depth = config.bStereoEFBMonoDepth;
backup_config.gpu_texture_decoding = config.bEnableGPUTextureDecoding; m_backup_config.gpu_texture_decoding = config.bEnableGPUTextureDecoding;
backup_config.disable_vram_copies = config.bDisableCopyToVRAM; m_backup_config.disable_vram_copies = config.bDisableCopyToVRAM;
backup_config.arbitrary_mipmap_detection = config.bArbitraryMipmapDetection; m_backup_config.arbitrary_mipmap_detection = config.bArbitraryMipmapDetection;
backup_config.graphics_mods = config.bGraphicMods; m_backup_config.graphics_mods = config.bGraphicMods;
backup_config.graphics_mod_change_count = m_backup_config.graphics_mod_change_count =
config.graphics_mod_config ? config.graphics_mod_config->GetChangeCount() : 0; config.graphics_mod_config ? config.graphics_mod_config->GetChangeCount() : 0;
} }
@ -348,7 +348,7 @@ RcTcacheEntry TextureCacheBase::ApplyPaletteToEntry(RcTcacheEntry& entry, const
g_gfx->EndUtilityDrawing(); g_gfx->EndUtilityDrawing();
} }
textures_by_address.emplace(decoded_entry->addr, decoded_entry); m_textures_by_address.emplace(decoded_entry->addr, decoded_entry);
return decoded_entry; return decoded_entry;
} }
@ -394,7 +394,7 @@ RcTcacheEntry TextureCacheBase::ReinterpretEntry(const RcTcacheEntry& existing_e
g_gfx->EndUtilityDrawing(); g_gfx->EndUtilityDrawing();
reinterpreted_entry->texture->FinishedRendering(); reinterpreted_entry->texture->FinishedRendering();
textures_by_address.emplace(reinterpreted_entry->addr, reinterpreted_entry); m_textures_by_address.emplace(reinterpreted_entry->addr, reinterpreted_entry);
return reinterpreted_entry; return reinterpreted_entry;
} }
@ -431,7 +431,7 @@ void TextureCacheBase::ScaleTextureCacheEntryTo(RcTcacheEntry& entry, u32 new_wi
// At this point new_texture has the old texture in it, // At this point new_texture has the old texture in it,
// we can potentially reuse this, so let's move it back to the pool // we can potentially reuse this, so let's move it back to the pool
auto config = new_texture->texture->GetConfig(); auto config = new_texture->texture->GetConfig();
texture_pool.emplace( m_texture_pool.emplace(
config, TexPoolEntry(std::move(new_texture->texture), std::move(new_texture->framebuffer))); config, TexPoolEntry(std::move(new_texture->texture), std::move(new_texture->framebuffer)));
} }
@ -562,7 +562,7 @@ void TextureCacheBase::DoState(PointerWrap& p)
// Flush all pending XFB copies before either loading or saving. // Flush all pending XFB copies before either loading or saving.
FlushEFBCopies(); FlushEFBCopies();
p.Do(last_entry_id); p.Do(m_last_entry_id);
if (p.IsWriteMode() || p.IsMeasureMode()) if (p.IsWriteMode() || p.IsMeasureMode())
DoSaveState(p); DoSaveState(p);
@ -601,14 +601,14 @@ void TextureCacheBase::DoSaveState(PointerWrap& p)
return iter != entry_map.end() ? std::make_optional(iter->second) : std::nullopt; return iter != entry_map.end() ? std::make_optional(iter->second) : std::nullopt;
}; };
// Transform the textures_by_address and textures_by_hash maps to a mapping // Transform the m_textures_by_address and m_textures_by_hash maps to a mapping
// of address/hash to entry ID. // of address/hash to entry ID.
std::vector<std::pair<u32, u32>> textures_by_address_list; std::vector<std::pair<u32, u32>> textures_by_address_list;
std::vector<std::pair<u64, u32>> textures_by_hash_list; std::vector<std::pair<u64, u32>> textures_by_hash_list;
std::vector<std::pair<u32, u32>> bound_textures_list; std::vector<std::pair<u32, u32>> bound_textures_list;
if (Config::Get(Config::GFX_SAVE_TEXTURE_CACHE_TO_STATE)) if (Config::Get(Config::GFX_SAVE_TEXTURE_CACHE_TO_STATE))
{ {
for (const auto& it : textures_by_address) for (const auto& it : m_textures_by_address)
{ {
if (ShouldSaveEntry(it.second)) if (ShouldSaveEntry(it.second))
{ {
@ -616,7 +616,7 @@ void TextureCacheBase::DoSaveState(PointerWrap& p)
textures_by_address_list.emplace_back(it.first, id); textures_by_address_list.emplace_back(it.first, id);
} }
} }
for (const auto& it : textures_by_hash) for (const auto& it : m_textures_by_hash)
{ {
if (ShouldSaveEntry(it.second)) if (ShouldSaveEntry(it.second))
{ {
@ -624,10 +624,10 @@ void TextureCacheBase::DoSaveState(PointerWrap& p)
textures_by_hash_list.emplace_back(it.first, id); textures_by_hash_list.emplace_back(it.first, id);
} }
} }
for (u32 i = 0; i < bound_textures.size(); i++) for (u32 i = 0; i < m_bound_textures.size(); i++)
{ {
const auto& tentry = bound_textures[i]; const auto& tentry = m_bound_textures[i];
if (bound_textures[i] && ShouldSaveEntry(tentry)) if (m_bound_textures[i] && ShouldSaveEntry(tentry))
{ {
const u32 id = AddCacheEntryToMap(tentry); const u32 id = AddCacheEntryToMap(tentry);
bound_textures_list.emplace_back(i, id); bound_textures_list.emplace_back(i, id);
@ -715,7 +715,7 @@ void TextureCacheBase::DoLoadState(PointerWrap& p)
auto tex = DeserializeTexture(p); auto tex = DeserializeTexture(p);
auto entry = auto entry =
std::make_shared<TCacheEntry>(std::move(tex->texture), std::move(tex->framebuffer)); std::make_shared<TCacheEntry>(std::move(tex->texture), std::move(tex->framebuffer));
entry->textures_by_hash_iter = textures_by_hash.end(); entry->textures_by_hash_iter = m_textures_by_hash.end();
entry->DoState(p); entry->DoState(p);
if (entry->texture && commit_state) if (entry->texture && commit_state)
id_map.emplace(i, entry); id_map.emplace(i, entry);
@ -746,7 +746,7 @@ void TextureCacheBase::DoLoadState(PointerWrap& p)
auto& entry = GetEntry(id); auto& entry = GetEntry(id);
if (entry) if (entry)
textures_by_address.emplace(addr, entry); m_textures_by_address.emplace(addr, entry);
} }
// Fill in hash map. // Fill in hash map.
@ -760,12 +760,12 @@ void TextureCacheBase::DoLoadState(PointerWrap& p)
auto& entry = GetEntry(id); auto& entry = GetEntry(id);
if (entry) if (entry)
entry->textures_by_hash_iter = textures_by_hash.emplace(hash, entry); entry->textures_by_hash_iter = m_textures_by_hash.emplace(hash, entry);
} }
// Clear bound textures // Clear bound textures
for (u32 i = 0; i < bound_textures.size(); i++) for (u32 i = 0; i < m_bound_textures.size(); i++)
bound_textures[i].reset(); m_bound_textures[i].reset();
// Fill in bound textures // Fill in bound textures
p.Do(size); p.Do(size);
@ -778,7 +778,7 @@ void TextureCacheBase::DoLoadState(PointerWrap& p)
auto& entry = GetEntry(id); auto& entry = GetEntry(id);
if (entry) if (entry)
bound_textures[index] = entry; m_bound_textures[index] = entry;
} }
} }
@ -1114,9 +1114,9 @@ void TextureCacheBase::BindTextures(BitSet32 used_textures)
{ {
auto& system = Core::System::GetInstance(); auto& system = Core::System::GetInstance();
auto& pixel_shader_manager = system.GetPixelShaderManager(); auto& pixel_shader_manager = system.GetPixelShaderManager();
for (u32 i = 0; i < bound_textures.size(); i++) for (u32 i = 0; i < m_bound_textures.size(); i++)
{ {
const RcTcacheEntry& tentry = bound_textures[i]; const RcTcacheEntry& tentry = m_bound_textures[i];
if (used_textures[i] && tentry) if (used_textures[i] && tentry)
{ {
g_gfx->SetTexture(i, tentry->texture.get()); g_gfx->SetTexture(i, tentry->texture.get());
@ -1295,9 +1295,9 @@ TCacheEntry* TextureCacheBase::LoadImpl(const TextureInfo& texture_info, bool fo
{ {
// if this stage was not invalidated by changes to texture registers, keep the current texture // if this stage was not invalidated by changes to texture registers, keep the current texture
if (!force_reload && TMEM::IsValid(texture_info.GetStage()) && if (!force_reload && TMEM::IsValid(texture_info.GetStage()) &&
bound_textures[texture_info.GetStage()]) m_bound_textures[texture_info.GetStage()])
{ {
TCacheEntry* entry = bound_textures[texture_info.GetStage()].get(); TCacheEntry* entry = m_bound_textures[texture_info.GetStage()].get();
// If the TMEM configuration is such that this texture is more or less guaranteed to still // If the TMEM configuration is such that this texture is more or less guaranteed to still
// be in TMEM, then we know we can reuse the old entry without even hashing the memory // be in TMEM, then we know we can reuse the old entry without even hashing the memory
// //
@ -1337,7 +1337,7 @@ TCacheEntry* TextureCacheBase::LoadImpl(const TextureInfo& texture_info, bool fo
action->OnTextureLoad(&texture_load); action->OnTextureLoad(&texture_load);
} }
} }
bound_textures[texture_info.GetStage()] = entry; m_bound_textures[texture_info.GetStage()] = entry;
// We need to keep track of invalided textures until they have actually been replaced or // We need to keep track of invalided textures until they have actually been replaced or
// re-loaded // re-loaded
@ -1427,12 +1427,12 @@ RcTcacheEntry TextureCacheBase::GetTexture(const int textureCacheSafetyColorSamp
// //
// For efb copies, the entry created in CopyRenderTargetToTexture always has to be used, or else // For efb copies, the entry created in CopyRenderTargetToTexture always has to be used, or else
// it was done in vain. // it was done in vain.
auto iter_range = textures_by_address.equal_range(texture_info.GetRawAddress()); auto iter_range = m_textures_by_address.equal_range(texture_info.GetRawAddress());
TexAddrCache::iterator iter = iter_range.first; TexAddrCache::iterator iter = iter_range.first;
TexAddrCache::iterator oldest_entry = iter; TexAddrCache::iterator oldest_entry = iter;
int temp_frameCount = 0x7fffffff; int temp_frameCount = 0x7fffffff;
TexAddrCache::iterator unconverted_copy = textures_by_address.end(); TexAddrCache::iterator unconverted_copy = m_textures_by_address.end();
TexAddrCache::iterator unreinterpreted_copy = textures_by_address.end(); TexAddrCache::iterator unreinterpreted_copy = m_textures_by_address.end();
while (iter != iter_range.second) while (iter != iter_range.second)
{ {
@ -1482,7 +1482,7 @@ RcTcacheEntry TextureCacheBase::GetTexture(const int textureCacheSafetyColorSamp
else else
{ {
// Prefer the already-converted copy. // Prefer the already-converted copy.
unconverted_copy = textures_by_address.end(); unconverted_copy = m_textures_by_address.end();
} }
// TODO: We should check width/height/levels for EFB copies. I'm not sure what effect // TODO: We should check width/height/levels for EFB copies. I'm not sure what effect
@ -1540,7 +1540,7 @@ RcTcacheEntry TextureCacheBase::GetTexture(const int textureCacheSafetyColorSamp
++iter; ++iter;
} }
if (unreinterpreted_copy != textures_by_address.end()) if (unreinterpreted_copy != m_textures_by_address.end())
{ {
auto decoded_entry = auto decoded_entry =
ReinterpretEntry(unreinterpreted_copy->second, texture_info.GetTextureFormat()); ReinterpretEntry(unreinterpreted_copy->second, texture_info.GetTextureFormat());
@ -1554,7 +1554,7 @@ RcTcacheEntry TextureCacheBase::GetTexture(const int textureCacheSafetyColorSamp
return decoded_entry; return decoded_entry;
} }
if (unconverted_copy != textures_by_address.end()) if (unconverted_copy != m_textures_by_address.end())
{ {
auto decoded_entry = ApplyPaletteToEntry( auto decoded_entry = ApplyPaletteToEntry(
unconverted_copy->second, texture_info.GetTlutAddress(), texture_info.GetTlutFormat()); unconverted_copy->second, texture_info.GetTlutAddress(), texture_info.GetTlutFormat());
@ -1575,7 +1575,7 @@ RcTcacheEntry TextureCacheBase::GetTexture(const int textureCacheSafetyColorSamp
std::max(texture_info.GetTextureSize(), palette_size) <= std::max(texture_info.GetTextureSize(), palette_size) <=
(u32)textureCacheSafetyColorSampleSize * 8) (u32)textureCacheSafetyColorSampleSize * 8)
{ {
auto hash_range = textures_by_hash.equal_range(full_hash); auto hash_range = m_textures_by_hash.equal_range(full_hash);
TexHashCache::iterator hash_iter = hash_range.first; TexHashCache::iterator hash_iter = hash_range.first;
while (hash_iter != hash_range.second) while (hash_iter != hash_range.second)
{ {
@ -1777,7 +1777,7 @@ RcTcacheEntry TextureCacheBase::CreateTextureEntry(
total_texture_size += mip_downsample_buffer_size; total_texture_size += mip_downsample_buffer_size;
CheckTempSize(total_texture_size); CheckTempSize(total_texture_size);
dst_buffer = temp; dst_buffer = m_temp;
if (!(texture_info.GetTextureFormat() == TextureFormat::RGBA8 && texture_info.IsFromTmem())) if (!(texture_info.GetTextureFormat() == TextureFormat::RGBA8 && texture_info.IsFromTmem()))
{ {
TexDecoder_Decode(dst_buffer, texture_info.GetData(), expanded_width, expanded_height, TexDecoder_Decode(dst_buffer, texture_info.GetData(), expanded_width, expanded_height,
@ -1841,12 +1841,12 @@ RcTcacheEntry TextureCacheBase::CreateTextureEntry(
} }
} }
const auto iter = textures_by_address.emplace(texture_info.GetRawAddress(), entry); const auto iter = m_textures_by_address.emplace(texture_info.GetRawAddress(), entry);
if (safety_color_sample_size == 0 || if (safety_color_sample_size == 0 ||
std::max(texture_info.GetTextureSize(), creation_info.palette_size) <= std::max(texture_info.GetTextureSize(), creation_info.palette_size) <=
(u32)safety_color_sample_size * 8) (u32)safety_color_sample_size * 8)
{ {
entry->textures_by_hash_iter = textures_by_hash.emplace(creation_info.full_hash, entry); entry->textures_by_hash_iter = m_textures_by_hash.emplace(creation_info.full_hash, entry);
} }
const TextureAndTLUTFormat full_format(texture_info.GetTextureFormat(), const TextureAndTLUTFormat full_format(texture_info.GetTextureFormat(),
@ -1860,7 +1860,7 @@ RcTcacheEntry TextureCacheBase::CreateTextureEntry(
entry->SetNotCopy(); entry->SetNotCopy();
INCSTAT(g_stats.num_textures_uploaded); INCSTAT(g_stats.num_textures_uploaded);
SETSTAT(g_stats.num_textures_alive, static_cast<int>(textures_by_address.size())); SETSTAT(g_stats.num_textures_alive, static_cast<int>(m_textures_by_address.size()));
entry = DoPartialTextureUpdates(iter->second, texture_info.GetTlutAddress(), entry = DoPartialTextureUpdates(iter->second, texture_info.GetTlutAddress(),
texture_info.GetTlutFormat()); texture_info.GetTlutFormat());
@ -1930,8 +1930,8 @@ RcTcacheEntry TextureCacheBase::GetXFBTexture(u32 address, u32 width, u32 height
{ {
const u32 decoded_size = width * height * sizeof(u32); const u32 decoded_size = width * height * sizeof(u32);
CheckTempSize(decoded_size); CheckTempSize(decoded_size);
TexDecoder_DecodeXFB(temp, src_data, width, height, stride); TexDecoder_DecodeXFB(m_temp, src_data, width, height, stride);
entry->texture->Load(0, width, height, width, temp, decoded_size); entry->texture->Load(0, width, height, width, m_temp, decoded_size);
} }
// Stitch any VRAM copies into the new RAM copy. // Stitch any VRAM copies into the new RAM copy.
@ -1939,8 +1939,8 @@ RcTcacheEntry TextureCacheBase::GetXFBTexture(u32 address, u32 width, u32 height
entry->texture->FinishedRendering(); entry->texture->FinishedRendering();
// Insert into the texture cache so we can re-use it next frame, if needed. // Insert into the texture cache so we can re-use it next frame, if needed.
textures_by_address.emplace(entry->addr, entry); m_textures_by_address.emplace(entry->addr, entry);
SETSTAT(g_stats.num_textures_alive, static_cast<int>(textures_by_address.size())); SETSTAT(g_stats.num_textures_alive, static_cast<int>(m_textures_by_address.size()));
INCSTAT(g_stats.num_textures_uploaded); INCSTAT(g_stats.num_textures_uploaded);
if (g_ActiveConfig.bDumpXFBTarget || g_ActiveConfig.bGraphicMods) if (g_ActiveConfig.bDumpXFBTarget || g_ActiveConfig.bGraphicMods)
@ -1965,7 +1965,7 @@ RcTcacheEntry TextureCacheBase::GetXFBTexture(u32 address, u32 width, u32 height
RcTcacheEntry TextureCacheBase::GetXFBFromCache(u32 address, u32 width, u32 height, u32 stride) RcTcacheEntry TextureCacheBase::GetXFBFromCache(u32 address, u32 width, u32 height, u32 stride)
{ {
auto iter_range = textures_by_address.equal_range(address); auto iter_range = m_textures_by_address.equal_range(address);
TexAddrCache::iterator iter = iter_range.first; TexAddrCache::iterator iter = iter_range.first;
while (iter != iter_range.second) while (iter != iter_range.second)
@ -2526,10 +2526,10 @@ void TextureCacheBase::CopyRenderTargetToTexture(
// Do not load textures by hash, if they were at least partly overwritten by an efb copy. // Do not load textures by hash, if they were at least partly overwritten by an efb copy.
// In this case, comparing the hash is not enough to check, if two textures are identical. // In this case, comparing the hash is not enough to check, if two textures are identical.
if (overlapping_entry->textures_by_hash_iter != textures_by_hash.end()) if (overlapping_entry->textures_by_hash_iter != m_textures_by_hash.end())
{ {
textures_by_hash.erase(overlapping_entry->textures_by_hash_iter); m_textures_by_hash.erase(overlapping_entry->textures_by_hash_iter);
overlapping_entry->textures_by_hash_iter = textures_by_hash.end(); overlapping_entry->textures_by_hash_iter = m_textures_by_hash.end();
} }
} }
++iter.first; ++iter.first;
@ -2553,7 +2553,7 @@ void TextureCacheBase::CopyRenderTargetToTexture(
{ {
const u64 hash = entry->CalculateHash(); const u64 hash = entry->CalculateHash();
entry->SetHashes(hash, hash); entry->SetHashes(hash, hash);
textures_by_address.emplace(dstAddr, std::move(entry)); m_textures_by_address.emplace(dstAddr, std::move(entry));
} }
} }
@ -2569,10 +2569,10 @@ void TextureCacheBase::FlushEFBCopies()
void TextureCacheBase::FlushStaleBinds() void TextureCacheBase::FlushStaleBinds()
{ {
for (u32 i = 0; i < bound_textures.size(); i++) for (u32 i = 0; i < m_bound_textures.size(); i++)
{ {
if (!TMEM::IsCached(i)) if (!TMEM::IsCached(i))
bound_textures[i].reset(); m_bound_textures[i].reset();
} }
} }
@ -2709,8 +2709,8 @@ RcTcacheEntry TextureCacheBase::AllocateCacheEntry(const TextureConfig& config)
auto cacheEntry = auto cacheEntry =
std::make_shared<TCacheEntry>(std::move(alloc->texture), std::move(alloc->framebuffer)); std::make_shared<TCacheEntry>(std::move(alloc->texture), std::move(alloc->framebuffer));
cacheEntry->textures_by_hash_iter = textures_by_hash.end(); cacheEntry->textures_by_hash_iter = m_textures_by_hash.end();
cacheEntry->id = last_entry_id++; cacheEntry->id = m_last_entry_id++;
return cacheEntry; return cacheEntry;
} }
@ -2718,10 +2718,10 @@ std::optional<TextureCacheBase::TexPoolEntry>
TextureCacheBase::AllocateTexture(const TextureConfig& config) TextureCacheBase::AllocateTexture(const TextureConfig& config)
{ {
TexPool::iterator iter = FindMatchingTextureFromPool(config); TexPool::iterator iter = FindMatchingTextureFromPool(config);
if (iter != texture_pool.end()) if (iter != m_texture_pool.end())
{ {
auto entry = std::move(iter->second); auto entry = std::move(iter->second);
texture_pool.erase(iter); m_texture_pool.erase(iter);
return std::move(entry); return std::move(entry);
} }
@ -2757,16 +2757,16 @@ TextureCacheBase::FindMatchingTextureFromPool(const TextureConfig& config)
// which potentially means that a driver has to maintain two copies of the texture anyway. // which potentially means that a driver has to maintain two copies of the texture anyway.
// Render-target textures are fine through, as they have to be generated in a seperated pass. // Render-target textures are fine through, as they have to be generated in a seperated pass.
// As non-render-target textures are usually static, this should not matter much. // As non-render-target textures are usually static, this should not matter much.
auto range = texture_pool.equal_range(config); auto range = m_texture_pool.equal_range(config);
auto matching_iter = std::find_if(range.first, range.second, [](const auto& iter) { auto matching_iter = std::find_if(range.first, range.second, [](const auto& iter) {
return iter.first.IsRenderTarget() || iter.second.frameCount != FRAMECOUNT_INVALID; return iter.first.IsRenderTarget() || iter.second.frameCount != FRAMECOUNT_INVALID;
}); });
return matching_iter != range.second ? matching_iter : texture_pool.end(); return matching_iter != range.second ? matching_iter : m_texture_pool.end();
} }
TextureCacheBase::TexAddrCache::iterator TextureCacheBase::GetTexCacheIter(TCacheEntry* entry) TextureCacheBase::TexAddrCache::iterator TextureCacheBase::GetTexCacheIter(TCacheEntry* entry)
{ {
auto iter_range = textures_by_address.equal_range(entry->addr); auto iter_range = m_textures_by_address.equal_range(entry->addr);
TexAddrCache::iterator iter = iter_range.first; TexAddrCache::iterator iter = iter_range.first;
while (iter != iter_range.second) while (iter != iter_range.second)
{ {
@ -2776,7 +2776,7 @@ TextureCacheBase::TexAddrCache::iterator TextureCacheBase::GetTexCacheIter(TCach
} }
++iter; ++iter;
} }
return textures_by_address.end(); return m_textures_by_address.end();
} }
std::pair<TextureCacheBase::TexAddrCache::iterator, TextureCacheBase::TexAddrCache::iterator> std::pair<TextureCacheBase::TexAddrCache::iterator, TextureCacheBase::TexAddrCache::iterator>
@ -2790,8 +2790,8 @@ TextureCacheBase::FindOverlappingTextures(u32 addr, u32 size_in_bytes)
// 1024 x 1024 texel times 8 nibbles per texel // 1024 x 1024 texel times 8 nibbles per texel
constexpr u32 max_texture_size = 1024 * 1024 * 4; constexpr u32 max_texture_size = 1024 * 1024 * 4;
u32 lower_addr = addr > max_texture_size ? addr - max_texture_size : 0; u32 lower_addr = addr > max_texture_size ? addr - max_texture_size : 0;
auto begin = textures_by_address.lower_bound(lower_addr); auto begin = m_textures_by_address.lower_bound(lower_addr);
auto end = textures_by_address.upper_bound(addr + size_in_bytes); auto end = m_textures_by_address.upper_bound(addr + size_in_bytes);
return std::make_pair(begin, end); return std::make_pair(begin, end);
} }
@ -2799,15 +2799,15 @@ TextureCacheBase::FindOverlappingTextures(u32 addr, u32 size_in_bytes)
TextureCacheBase::TexAddrCache::iterator TextureCacheBase::TexAddrCache::iterator
TextureCacheBase::InvalidateTexture(TexAddrCache::iterator iter, bool discard_pending_efb_copy) TextureCacheBase::InvalidateTexture(TexAddrCache::iterator iter, bool discard_pending_efb_copy)
{ {
if (iter == textures_by_address.end()) if (iter == m_textures_by_address.end())
return textures_by_address.end(); return m_textures_by_address.end();
RcTcacheEntry& entry = iter->second; RcTcacheEntry& entry = iter->second;
if (entry->textures_by_hash_iter != textures_by_hash.end()) if (entry->textures_by_hash_iter != m_textures_by_hash.end())
{ {
textures_by_hash.erase(entry->textures_by_hash_iter); m_textures_by_hash.erase(entry->textures_by_hash_iter);
entry->textures_by_hash_iter = textures_by_hash.end(); entry->textures_by_hash_iter = m_textures_by_hash.end();
} }
// If this is a pending EFB copy, we don't want to flush it here. // If this is a pending EFB copy, we don't want to flush it here.
@ -2840,7 +2840,7 @@ TextureCacheBase::InvalidateTexture(TexAddrCache::iterator iter, bool discard_pe
} }
entry->invalidated = true; entry->invalidated = true;
return textures_by_address.erase(iter); return m_textures_by_address.erase(iter);
} }
void TextureCacheBase::ReleaseToPool(TCacheEntry* entry) void TextureCacheBase::ReleaseToPool(TCacheEntry* entry)
@ -2848,8 +2848,8 @@ void TextureCacheBase::ReleaseToPool(TCacheEntry* entry)
if (!entry->texture) if (!entry->texture)
return; return;
auto config = entry->texture->GetConfig(); auto config = entry->texture->GetConfig();
texture_pool.emplace(config, m_texture_pool.emplace(config,
TexPoolEntry(std::move(entry->texture), std::move(entry->framebuffer))); TexPoolEntry(std::move(entry->texture), std::move(entry->framebuffer)));
} }
bool TextureCacheBase::CreateUtilityTextures() bool TextureCacheBase::CreateUtilityTextures()

28
Source/Core/VideoCommon/TextureCacheBase.h
View File

@ -138,7 +138,7 @@ struct TCacheEntry
u64 id = 0; u64 id = 0;
u32 content_semaphore = 0; // Counts up u32 content_semaphore = 0; // Counts up
// Indicates that this TCacheEntry has been invalided from textures_by_address // Indicates that this TCacheEntry has been invalided from m_textures_by_address
bool invalidated = false; bool invalidated = false;
bool reference_changed = false; // used by xfb to determine when a reference xfb changed bool reference_changed = false; // used by xfb to determine when a reference xfb changed
@ -151,7 +151,7 @@ struct TCacheEntry
// used to delete textures which haven't been used for TEXTURE_KILL_THRESHOLD frames // used to delete textures which haven't been used for TEXTURE_KILL_THRESHOLD frames
int frameCount = FRAMECOUNT_INVALID; int frameCount = FRAMECOUNT_INVALID;
// Keep an iterator to the entry in textures_by_hash, so it does not need to be searched when // Keep an iterator to the entry in m_textures_by_hash, so it does not need to be searched when
// removing the cache entry // removing the cache entry
std::multimap<u64, std::shared_ptr<TCacheEntry>>::iterator textures_by_hash_iter; std::multimap<u64, std::shared_ptr<TCacheEntry>>::iterator textures_by_hash_iter;
@ -330,8 +330,8 @@ protected:
float gamma, bool clamp_top, bool clamp_bottom, float gamma, bool clamp_top, bool clamp_bottom,
const std::array<u32, 3>& filter_coefficients); const std::array<u32, 3>& filter_coefficients);
alignas(16) u8* temp = nullptr; alignas(16) u8* m_temp = nullptr;
size_t temp_size = 0; size_t m_temp_size = 0;
private: private:
using TexAddrCache = std::multimap<u32, RcTcacheEntry>; using TexAddrCache = std::multimap<u32, RcTcacheEntry>;
@ -405,20 +405,20 @@ private:
void DoSaveState(PointerWrap& p); void DoSaveState(PointerWrap& p);
void DoLoadState(PointerWrap& p); void DoLoadState(PointerWrap& p);
// textures_by_address is the authoritive version of what's actually "in" the texture cache // m_textures_by_address is the authoritive version of what's actually "in" the texture cache
// but it's possible for invalidated TCache entries to live on elsewhere // but it's possible for invalidated TCache entries to live on elsewhere
TexAddrCache textures_by_address; TexAddrCache m_textures_by_address;
// textures_by_hash is an alternative view of the texture cache // m_textures_by_hash is an alternative view of the texture cache
// All textures in here will also be in textures_by_address // All textures in here will also be in m_textures_by_address
TexHashCache textures_by_hash; TexHashCache m_textures_by_hash;
// bound_textures are actually active in the current draw // m_bound_textures are actually active in the current draw
// It's valid for textures to be in here after they've been invalidated // It's valid for textures to be in here after they've been invalidated
std::array<RcTcacheEntry, 8> bound_textures{}; std::array<RcTcacheEntry, 8> m_bound_textures{};
TexPool texture_pool; TexPool m_texture_pool;
u64 last_entry_id = 0; u64 m_last_entry_id = 0;
// Backup configuration values // Backup configuration values
struct BackupConfig struct BackupConfig
@ -437,7 +437,7 @@ private:
bool graphics_mods; bool graphics_mods;
u32 graphics_mod_change_count; u32 graphics_mod_change_count;
}; };
BackupConfig backup_config = {}; BackupConfig m_backup_config = {};
// Encoding texture used for EFB copies to RAM. // Encoding texture used for EFB copies to RAM.
std::unique_ptr<AbstractTexture> m_efb_encoding_texture; std::unique_ptr<AbstractTexture> m_efb_encoding_texture;