206 changes: 103 additions & 103 deletions Source/Core/VideoCommon/TextureCacheBase.cpp
View file
Expand Up @@ -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<u8*>(Common::AllocateAlignedMemory(temp_size, 16));
m_temp_size = required_size;
Common::FreeAlignedMemory(m_temp);
m_temp = static_cast<u8*>(Common::AllocateAlignedMemory(m_temp_size, 16));
}

TextureCacheBase::TextureCacheBase()
{
SetBackupConfig(g_ActiveConfig);

temp_size = 2048 * 2048 * 4;
temp = static_cast<u8*>(Common::AllocateAlignedMemory(temp_size, 16));
m_temp_size = 2048 * 2048 * 4;
m_temp = static_cast<u8*>(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();

Expand All @@ -117,8 +117,8 @@ void TextureCacheBase::Shutdown()

TextureCacheBase::~TextureCacheBase()
{
Common::FreeAlignedMemory(temp);
temp = nullptr;
Common::FreeAlignedMemory(m_temp);
m_temp = nullptr;
}

bool TextureCacheBase::Initialize()
Expand All @@ -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();
}
Expand All @@ -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);
Expand All @@ -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)
Expand Down Expand Up @@ -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)
Expand All @@ -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
{
Expand All @@ -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;
}

Expand Down Expand Up @@ -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;
}
Expand Down Expand Up @@ -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;
}
Expand Down Expand Up @@ -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)));
}

Expand Down Expand Up @@ -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);
Expand Down Expand Up @@ -601,33 +601,33 @@ 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<std::pair<u32, u32>> textures_by_address_list;
std::vector<std::pair<u64, u32>> textures_by_hash_list;
std::vector<std::pair<u32, u32>> 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))
{
const u32 id = AddCacheEntryToMap(it.second);
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))
{
const u32 id = AddCacheEntryToMap(it.second);
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);
Expand Down Expand Up @@ -715,7 +715,7 @@ void TextureCacheBase::DoLoadState(PointerWrap& p)
auto tex = DeserializeTexture(p);
auto entry =
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);
if (entry->texture && commit_state)
id_map.emplace(i, entry);
Expand Down Expand Up @@ -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.
Expand All @@ -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);
Expand All @@ -778,7 +778,7 @@ void TextureCacheBase::DoLoadState(PointerWrap& p)

auto& entry = GetEntry(id);
if (entry)
bound_textures[index] = entry;
m_bound_textures[index] = entry;
}
}

Expand Down Expand Up @@ -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());
Expand Down Expand Up @@ -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
//
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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)
{
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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());
Expand All @@ -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());
Expand All @@ -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)
{
Expand Down Expand Up @@ -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,
Expand Down Expand Up @@ -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(),
Expand All @@ -1860,7 +1860,7 @@ RcTcacheEntry TextureCacheBase::CreateTextureEntry(
entry->SetNotCopy();

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(),
texture_info.GetTlutFormat());
Expand Down Expand Up @@ -1930,17 +1930,17 @@ 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.
StitchXFBCopy(entry);
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<int>(textures_by_address.size()));
m_textures_by_address.emplace(entry->addr, entry);
SETSTAT(g_stats.num_textures_alive, static_cast<int>(m_textures_by_address.size()));
INCSTAT(g_stats.num_textures_uploaded);

if (g_ActiveConfig.bDumpXFBTarget || g_ActiveConfig.bGraphicMods)
Expand All @@ -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)
Expand Down Expand Up @@ -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;
Expand All @@ -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));
}
}

Expand All @@ -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();
}
}

Expand Down Expand Up @@ -2709,19 +2709,19 @@ RcTcacheEntry TextureCacheBase::AllocateCacheEntry(const TextureConfig& config)

auto cacheEntry =
std::make_shared<TCacheEntry>(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;
}

std::optional<TextureCacheBase::TexPoolEntry>
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);
}

Expand Down Expand Up @@ -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)
{
Expand All @@ -2776,7 +2776,7 @@ TextureCacheBase::TexAddrCache::iterator TextureCacheBase::GetTexCacheIter(TCach
}
++iter;
}
return textures_by_address.end();
return m_textures_by_address.end();
}

std::pair<TextureCacheBase::TexAddrCache::iterator, TextureCacheBase::TexAddrCache::iterator>
Expand All @@ -2790,24 +2790,24 @@ 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);
}

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.
Expand Down Expand Up @@ -2840,16 +2840,16 @@ 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)
{
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()
Expand Down
28 changes: 14 additions & 14 deletions Source/Core/VideoCommon/TextureCacheBase.h
View file
Expand Up @@ -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
Expand All @@ -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<u64, std::shared_ptr<TCacheEntry>>::iterator textures_by_hash_iter;

Expand Down Expand Up @@ -330,8 +330,8 @@ class TextureCacheBase
float gamma, bool clamp_top, bool clamp_bottom,
const std::array<u32, 3>& 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<u32, RcTcacheEntry>;
Expand Down Expand Up @@ -405,20 +405,20 @@ class TextureCacheBase
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<RcTcacheEntry, 8> bound_textures{};
std::array<RcTcacheEntry, 8> 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
Expand All @@ -437,7 +437,7 @@ class TextureCacheBase
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<AbstractTexture> m_efb_encoding_texture;
Expand Down