From d5d3eb5025570e3e62e45d6985f9e34c356ceadd Mon Sep 17 00:00:00 2001 From: Dentomologist Date: Fri, 1 Sep 2023 22:50:48 -0700 Subject: [PATCH] TextureCacheBase: Add m_ prefix to member variables --- Source/Core/VideoCommon/TextureCacheBase.cpp | 206 +++++++++---------- Source/Core/VideoCommon/TextureCacheBase.h | 28 +-- 2 files changed, 117 insertions(+), 117 deletions(-) diff --git a/Source/Core/VideoCommon/TextureCacheBase.cpp b/Source/Core/VideoCommon/TextureCacheBase.cpp index 37dadba967..fddd8f7bee 100644 --- a/Source/Core/VideoCommon/TextureCacheBase.cpp +++ b/Source/Core/VideoCommon/TextureCacheBase.cpp @@ -81,23 +81,23 @@ TCacheEntry::~TCacheEntry() void TextureCacheBase::CheckTempSize(size_t required_size) { - if (required_size <= temp_size) + if (required_size <= m_temp_size) return; - temp_size = required_size; - Common::FreeAlignedMemory(temp); - temp = static_cast(Common::AllocateAlignedMemory(temp_size, 16)); + m_temp_size = required_size; + Common::FreeAlignedMemory(m_temp); + m_temp = static_cast(Common::AllocateAlignedMemory(m_temp_size, 16)); } TextureCacheBase::TextureCacheBase() { SetBackupConfig(g_ActiveConfig); - temp_size = 2048 * 2048 * 4; - temp = static_cast(Common::AllocateAlignedMemory(temp_size, 16)); + m_temp_size = 2048 * 2048 * 4; + m_temp = static_cast(Common::AllocateAlignedMemory(m_temp_size, 16)); - TexDecoder_SetTexFmtOverlayOptions(backup_config.texfmt_overlay, - backup_config.texfmt_overlay_center); + TexDecoder_SetTexFmtOverlayOptions(m_backup_config.texfmt_overlay, + m_backup_config.texfmt_overlay_center); HiresTexture::Init(); @@ -117,8 +117,8 @@ void TextureCacheBase::Shutdown() TextureCacheBase::~TextureCacheBase() { - Common::FreeAlignedMemory(temp); - temp = nullptr; + Common::FreeAlignedMemory(m_temp); + m_temp = nullptr; } bool TextureCacheBase::Initialize() @@ -137,18 +137,18 @@ void TextureCacheBase::Invalidate() FlushEFBCopies(); TMEM::InvalidateAll(); - for (auto& bind : bound_textures) + for (auto& bind : m_bound_textures) bind.reset(); - textures_by_hash.clear(); - textures_by_address.clear(); + m_textures_by_hash.clear(); + m_textures_by_address.clear(); - texture_pool.clear(); + m_texture_pool.clear(); } void TextureCacheBase::OnConfigChanged(const VideoConfig& config) { - if (config.bHiresTextures != backup_config.hires_textures || - config.bCacheHiresTextures != backup_config.cache_hires_textures) + if (config.bHiresTextures != m_backup_config.hires_textures || + config.bCacheHiresTextures != m_backup_config.cache_hires_textures) { HiresTexture::Update(); } @@ -157,15 +157,15 @@ void TextureCacheBase::OnConfigChanged(const VideoConfig& config) config.graphics_mod_config ? config.graphics_mod_config->GetChangeCount() : 0; // TODO: Invalidating texcache is really stupid in some of these cases - if (config.iSafeTextureCache_ColorSamples != backup_config.color_samples || - config.bTexFmtOverlayEnable != backup_config.texfmt_overlay || - config.bTexFmtOverlayCenter != backup_config.texfmt_overlay_center || - config.bHiresTextures != backup_config.hires_textures || - config.bEnableGPUTextureDecoding != backup_config.gpu_texture_decoding || - config.bDisableCopyToVRAM != backup_config.disable_vram_copies || - config.bArbitraryMipmapDetection != backup_config.arbitrary_mipmap_detection || - config.bGraphicMods != backup_config.graphics_mods || - change_count != backup_config.graphics_mod_change_count) + if (config.iSafeTextureCache_ColorSamples != m_backup_config.color_samples || + config.bTexFmtOverlayEnable != m_backup_config.texfmt_overlay || + config.bTexFmtOverlayCenter != m_backup_config.texfmt_overlay_center || + config.bHiresTextures != m_backup_config.hires_textures || + config.bEnableGPUTextureDecoding != m_backup_config.gpu_texture_decoding || + config.bDisableCopyToVRAM != m_backup_config.disable_vram_copies || + config.bArbitraryMipmapDetection != m_backup_config.arbitrary_mipmap_detection || + config.bGraphicMods != m_backup_config.graphics_mods || + change_count != m_backup_config.graphics_mod_change_count) { Invalidate(); TexDecoder_SetTexFmtOverlayOptions(config.bTexFmtOverlayEnable, config.bTexFmtOverlayCenter); @@ -176,8 +176,8 @@ void TextureCacheBase::OnConfigChanged(const VideoConfig& config) void TextureCacheBase::Cleanup(int _frameCount) { - TexAddrCache::iterator iter = textures_by_address.begin(); - TexAddrCache::iterator tcend = textures_by_address.end(); + TexAddrCache::iterator iter = m_textures_by_address.begin(); + TexAddrCache::iterator tcend = m_textures_by_address.end(); while (iter != tcend) { if (iter->second->frameCount == FRAMECOUNT_INVALID) @@ -214,8 +214,8 @@ void TextureCacheBase::Cleanup(int _frameCount) } } - TexPool::iterator iter2 = texture_pool.begin(); - TexPool::iterator tcend2 = texture_pool.end(); + TexPool::iterator iter2 = m_texture_pool.begin(); + TexPool::iterator tcend2 = m_texture_pool.end(); while (iter2 != tcend2) { if (iter2->second.frameCount == FRAMECOUNT_INVALID) @@ -224,7 +224,7 @@ void TextureCacheBase::Cleanup(int _frameCount) } if (_frameCount > TEXTURE_POOL_KILL_THRESHOLD + iter2->second.frameCount) { - iter2 = texture_pool.erase(iter2); + iter2 = m_texture_pool.erase(iter2); } else { @@ -246,18 +246,18 @@ bool TCacheEntry::OverlapsMemoryRange(u32 range_address, u32 range_size) const void TextureCacheBase::SetBackupConfig(const VideoConfig& config) { - backup_config.color_samples = config.iSafeTextureCache_ColorSamples; - backup_config.texfmt_overlay = config.bTexFmtOverlayEnable; - backup_config.texfmt_overlay_center = config.bTexFmtOverlayCenter; - backup_config.hires_textures = config.bHiresTextures; - backup_config.cache_hires_textures = config.bCacheHiresTextures; - backup_config.stereo_3d = config.stereo_mode != StereoMode::Off; - backup_config.efb_mono_depth = config.bStereoEFBMonoDepth; - backup_config.gpu_texture_decoding = config.bEnableGPUTextureDecoding; - backup_config.disable_vram_copies = config.bDisableCopyToVRAM; - backup_config.arbitrary_mipmap_detection = config.bArbitraryMipmapDetection; - backup_config.graphics_mods = config.bGraphicMods; - backup_config.graphics_mod_change_count = + m_backup_config.color_samples = config.iSafeTextureCache_ColorSamples; + m_backup_config.texfmt_overlay = config.bTexFmtOverlayEnable; + m_backup_config.texfmt_overlay_center = config.bTexFmtOverlayCenter; + m_backup_config.hires_textures = config.bHiresTextures; + m_backup_config.cache_hires_textures = config.bCacheHiresTextures; + m_backup_config.stereo_3d = config.stereo_mode != StereoMode::Off; + m_backup_config.efb_mono_depth = config.bStereoEFBMonoDepth; + m_backup_config.gpu_texture_decoding = config.bEnableGPUTextureDecoding; + m_backup_config.disable_vram_copies = config.bDisableCopyToVRAM; + m_backup_config.arbitrary_mipmap_detection = config.bArbitraryMipmapDetection; + m_backup_config.graphics_mods = config.bGraphicMods; + m_backup_config.graphics_mod_change_count = config.graphics_mod_config ? config.graphics_mod_config->GetChangeCount() : 0; } @@ -348,7 +348,7 @@ RcTcacheEntry TextureCacheBase::ApplyPaletteToEntry(RcTcacheEntry& entry, const 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; } @@ -394,7 +394,7 @@ RcTcacheEntry TextureCacheBase::ReinterpretEntry(const RcTcacheEntry& existing_e g_gfx->EndUtilityDrawing(); 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; } @@ -431,7 +431,7 @@ void TextureCacheBase::ScaleTextureCacheEntryTo(RcTcacheEntry& entry, u32 new_wi // 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 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))); } @@ -562,7 +562,7 @@ void TextureCacheBase::DoState(PointerWrap& p) // Flush all pending XFB copies before either loading or saving. FlushEFBCopies(); - p.Do(last_entry_id); + p.Do(m_last_entry_id); if (p.IsWriteMode() || p.IsMeasureMode()) DoSaveState(p); @@ -601,14 +601,14 @@ void TextureCacheBase::DoSaveState(PointerWrap& p) 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. std::vector> textures_by_address_list; std::vector> textures_by_hash_list; std::vector> bound_textures_list; 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)) { @@ -616,7 +616,7 @@ void TextureCacheBase::DoSaveState(PointerWrap& p) 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)) { @@ -624,10 +624,10 @@ void TextureCacheBase::DoSaveState(PointerWrap& p) 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]; - if (bound_textures[i] && ShouldSaveEntry(tentry)) + const auto& tentry = m_bound_textures[i]; + if (m_bound_textures[i] && ShouldSaveEntry(tentry)) { const u32 id = AddCacheEntryToMap(tentry); bound_textures_list.emplace_back(i, id); @@ -715,7 +715,7 @@ void TextureCacheBase::DoLoadState(PointerWrap& p) auto tex = DeserializeTexture(p); auto entry = std::make_shared(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); if (entry->texture && commit_state) id_map.emplace(i, entry); @@ -746,7 +746,7 @@ void TextureCacheBase::DoLoadState(PointerWrap& p) auto& entry = GetEntry(id); if (entry) - textures_by_address.emplace(addr, entry); + m_textures_by_address.emplace(addr, entry); } // Fill in hash map. @@ -760,12 +760,12 @@ void TextureCacheBase::DoLoadState(PointerWrap& p) auto& entry = GetEntry(id); 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 - for (u32 i = 0; i < bound_textures.size(); i++) - bound_textures[i].reset(); + for (u32 i = 0; i < m_bound_textures.size(); i++) + m_bound_textures[i].reset(); // Fill in bound textures p.Do(size); @@ -778,7 +778,7 @@ void TextureCacheBase::DoLoadState(PointerWrap& p) auto& entry = GetEntry(id); 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& 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) { 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 (!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 // 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); } } - 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 // 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 // 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 oldest_entry = iter; int temp_frameCount = 0x7fffffff; - TexAddrCache::iterator unconverted_copy = textures_by_address.end(); - TexAddrCache::iterator unreinterpreted_copy = textures_by_address.end(); + TexAddrCache::iterator unconverted_copy = m_textures_by_address.end(); + TexAddrCache::iterator unreinterpreted_copy = m_textures_by_address.end(); while (iter != iter_range.second) { @@ -1482,7 +1482,7 @@ RcTcacheEntry TextureCacheBase::GetTexture(const int textureCacheSafetyColorSamp else { // 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 @@ -1540,7 +1540,7 @@ RcTcacheEntry TextureCacheBase::GetTexture(const int textureCacheSafetyColorSamp ++iter; } - if (unreinterpreted_copy != textures_by_address.end()) + if (unreinterpreted_copy != m_textures_by_address.end()) { auto decoded_entry = ReinterpretEntry(unreinterpreted_copy->second, texture_info.GetTextureFormat()); @@ -1554,7 +1554,7 @@ RcTcacheEntry TextureCacheBase::GetTexture(const int textureCacheSafetyColorSamp return decoded_entry; } - if (unconverted_copy != textures_by_address.end()) + if (unconverted_copy != m_textures_by_address.end()) { auto decoded_entry = ApplyPaletteToEntry( 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) <= (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; while (hash_iter != hash_range.second) { @@ -1777,7 +1777,7 @@ RcTcacheEntry TextureCacheBase::CreateTextureEntry( total_texture_size += mip_downsample_buffer_size; CheckTempSize(total_texture_size); - dst_buffer = temp; + dst_buffer = m_temp; if (!(texture_info.GetTextureFormat() == TextureFormat::RGBA8 && texture_info.IsFromTmem())) { 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 || std::max(texture_info.GetTextureSize(), creation_info.palette_size) <= (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(), @@ -1860,7 +1860,7 @@ RcTcacheEntry TextureCacheBase::CreateTextureEntry( entry->SetNotCopy(); INCSTAT(g_stats.num_textures_uploaded); - SETSTAT(g_stats.num_textures_alive, static_cast(textures_by_address.size())); + SETSTAT(g_stats.num_textures_alive, static_cast(m_textures_by_address.size())); entry = DoPartialTextureUpdates(iter->second, texture_info.GetTlutAddress(), texture_info.GetTlutFormat()); @@ -1930,8 +1930,8 @@ RcTcacheEntry TextureCacheBase::GetXFBTexture(u32 address, u32 width, u32 height { const u32 decoded_size = width * height * sizeof(u32); CheckTempSize(decoded_size); - TexDecoder_DecodeXFB(temp, src_data, width, height, stride); - entry->texture->Load(0, width, height, width, temp, decoded_size); + TexDecoder_DecodeXFB(m_temp, src_data, width, height, stride); + entry->texture->Load(0, width, height, width, m_temp, decoded_size); } // 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(); // Insert into the texture cache so we can re-use it next frame, if needed. - textures_by_address.emplace(entry->addr, entry); - SETSTAT(g_stats.num_textures_alive, static_cast(textures_by_address.size())); + m_textures_by_address.emplace(entry->addr, entry); + SETSTAT(g_stats.num_textures_alive, static_cast(m_textures_by_address.size())); INCSTAT(g_stats.num_textures_uploaded); 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) { - 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; 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. // 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); - overlapping_entry->textures_by_hash_iter = textures_by_hash.end(); + m_textures_by_hash.erase(overlapping_entry->textures_by_hash_iter); + overlapping_entry->textures_by_hash_iter = m_textures_by_hash.end(); } } ++iter.first; @@ -2553,7 +2553,7 @@ void TextureCacheBase::CopyRenderTargetToTexture( { const u64 hash = entry->CalculateHash(); 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() { - for (u32 i = 0; i < bound_textures.size(); i++) + for (u32 i = 0; i < m_bound_textures.size(); 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 = std::make_shared(std::move(alloc->texture), std::move(alloc->framebuffer)); - cacheEntry->textures_by_hash_iter = textures_by_hash.end(); - cacheEntry->id = last_entry_id++; + cacheEntry->textures_by_hash_iter = m_textures_by_hash.end(); + cacheEntry->id = m_last_entry_id++; return cacheEntry; } @@ -2718,10 +2718,10 @@ std::optional TextureCacheBase::AllocateTexture(const TextureConfig& config) { TexPool::iterator iter = FindMatchingTextureFromPool(config); - if (iter != texture_pool.end()) + if (iter != m_texture_pool.end()) { auto entry = std::move(iter->second); - texture_pool.erase(iter); + m_texture_pool.erase(iter); 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. // 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. - 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) { 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) { - 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; while (iter != iter_range.second) { @@ -2776,7 +2776,7 @@ TextureCacheBase::TexAddrCache::iterator TextureCacheBase::GetTexCacheIter(TCach } ++iter; } - return textures_by_address.end(); + return m_textures_by_address.end(); } std::pair @@ -2790,8 +2790,8 @@ TextureCacheBase::FindOverlappingTextures(u32 addr, u32 size_in_bytes) // 1024 x 1024 texel times 8 nibbles per texel constexpr u32 max_texture_size = 1024 * 1024 * 4; u32 lower_addr = addr > max_texture_size ? addr - max_texture_size : 0; - auto begin = textures_by_address.lower_bound(lower_addr); - auto end = textures_by_address.upper_bound(addr + size_in_bytes); + auto begin = m_textures_by_address.lower_bound(lower_addr); + auto end = m_textures_by_address.upper_bound(addr + size_in_bytes); return std::make_pair(begin, end); } @@ -2799,15 +2799,15 @@ TextureCacheBase::FindOverlappingTextures(u32 addr, u32 size_in_bytes) TextureCacheBase::TexAddrCache::iterator TextureCacheBase::InvalidateTexture(TexAddrCache::iterator iter, bool discard_pending_efb_copy) { - if (iter == textures_by_address.end()) - return textures_by_address.end(); + if (iter == m_textures_by_address.end()) + return m_textures_by_address.end(); 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); - entry->textures_by_hash_iter = textures_by_hash.end(); + m_textures_by_hash.erase(entry->textures_by_hash_iter); + 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. @@ -2840,7 +2840,7 @@ TextureCacheBase::InvalidateTexture(TexAddrCache::iterator iter, bool discard_pe } entry->invalidated = true; - return textures_by_address.erase(iter); + return m_textures_by_address.erase(iter); } void TextureCacheBase::ReleaseToPool(TCacheEntry* entry) @@ -2848,8 +2848,8 @@ void TextureCacheBase::ReleaseToPool(TCacheEntry* entry) if (!entry->texture) return; auto config = entry->texture->GetConfig(); - texture_pool.emplace(config, - TexPoolEntry(std::move(entry->texture), std::move(entry->framebuffer))); + m_texture_pool.emplace(config, + TexPoolEntry(std::move(entry->texture), std::move(entry->framebuffer))); } bool TextureCacheBase::CreateUtilityTextures() diff --git a/Source/Core/VideoCommon/TextureCacheBase.h b/Source/Core/VideoCommon/TextureCacheBase.h index 3592535a65..3c942ed8c2 100644 --- a/Source/Core/VideoCommon/TextureCacheBase.h +++ b/Source/Core/VideoCommon/TextureCacheBase.h @@ -138,7 +138,7 @@ struct TCacheEntry u64 id = 0; 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 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 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 std::multimap>::iterator textures_by_hash_iter; @@ -330,8 +330,8 @@ protected: float gamma, bool clamp_top, bool clamp_bottom, const std::array& filter_coefficients); - alignas(16) u8* temp = nullptr; - size_t temp_size = 0; + alignas(16) u8* m_temp = nullptr; + size_t m_temp_size = 0; private: using TexAddrCache = std::multimap; @@ -405,20 +405,20 @@ private: void DoSaveState(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 - TexAddrCache textures_by_address; + TexAddrCache m_textures_by_address; - // textures_by_hash is an alternative view of the texture cache - // All textures in here will also be in textures_by_address - TexHashCache textures_by_hash; + // m_textures_by_hash is an alternative view of the texture cache + // All textures in here will also be in m_textures_by_address + 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 - std::array bound_textures{}; + std::array m_bound_textures{}; - TexPool texture_pool; - u64 last_entry_id = 0; + TexPool m_texture_pool; + u64 m_last_entry_id = 0; // Backup configuration values struct BackupConfig @@ -437,7 +437,7 @@ private: bool graphics_mods; u32 graphics_mod_change_count; }; - BackupConfig backup_config = {}; + BackupConfig m_backup_config = {}; // Encoding texture used for EFB copies to RAM. std::unique_ptr m_efb_encoding_texture;