2015-05-24 04:55:12 +00:00
|
|
|
// Copyright 2010 Dolphin Emulator Project
|
2015-05-17 23:08:10 +00:00
|
|
|
// Licensed under GPLv2+
|
2013-04-18 03:09:55 +00:00
|
|
|
// Refer to the license.txt file included.
|
2010-10-19 22:24:27 +00:00
|
|
|
|
2014-05-03 02:47:04 +00:00
|
|
|
#include <algorithm>
|
2017-10-18 09:02:56 +00:00
|
|
|
#include <cmath>
|
2016-01-17 21:54:31 +00:00
|
|
|
#include <cstring>
|
2015-12-21 02:49:49 +00:00
|
|
|
#include <memory>
|
2014-06-03 05:08:54 +00:00
|
|
|
#include <string>
|
2016-01-17 21:54:31 +00:00
|
|
|
#include <utility>
|
2014-05-03 02:47:04 +00:00
|
|
|
|
2016-11-27 10:56:22 +00:00
|
|
|
#include "Common/Align.h"
|
2016-01-17 21:54:31 +00:00
|
|
|
#include "Common/Assert.h"
|
|
|
|
#include "Common/CommonTypes.h"
|
2014-02-17 10:18:15 +00:00
|
|
|
#include "Common/FileUtil.h"
|
2016-01-17 21:54:31 +00:00
|
|
|
#include "Common/Hash.h"
|
2016-06-24 08:43:46 +00:00
|
|
|
#include "Common/Logging/Log.h"
|
2016-11-27 10:56:22 +00:00
|
|
|
#include "Common/MathUtil.h"
|
2014-02-17 10:18:15 +00:00
|
|
|
#include "Common/MemoryUtil.h"
|
2014-06-03 05:08:54 +00:00
|
|
|
#include "Common/StringUtil.h"
|
2010-10-19 22:24:27 +00:00
|
|
|
|
2014-02-17 10:18:15 +00:00
|
|
|
#include "Core/ConfigManager.h"
|
2015-09-06 14:31:32 +00:00
|
|
|
#include "Core/FifoPlayer/FifoPlayer.h"
|
2015-09-07 15:05:47 +00:00
|
|
|
#include "Core/FifoPlayer/FifoRecorder.h"
|
2014-02-17 10:18:15 +00:00
|
|
|
#include "Core/HW/Memmap.h"
|
2010-10-19 22:24:27 +00:00
|
|
|
|
2016-01-17 21:54:31 +00:00
|
|
|
#include "VideoCommon/BPMemory.h"
|
2014-02-17 10:18:15 +00:00
|
|
|
#include "VideoCommon/Debugger.h"
|
2015-01-11 14:03:41 +00:00
|
|
|
#include "VideoCommon/FramebufferManagerBase.h"
|
2014-02-17 10:18:15 +00:00
|
|
|
#include "VideoCommon/HiresTextures.h"
|
|
|
|
#include "VideoCommon/RenderBase.h"
|
2016-03-24 02:42:08 +00:00
|
|
|
#include "VideoCommon/SamplerCommon.h"
|
2014-02-17 10:18:15 +00:00
|
|
|
#include "VideoCommon/Statistics.h"
|
|
|
|
#include "VideoCommon/TextureCacheBase.h"
|
2016-01-17 21:54:31 +00:00
|
|
|
#include "VideoCommon/TextureDecoder.h"
|
2015-09-07 15:05:47 +00:00
|
|
|
#include "VideoCommon/VideoCommon.h"
|
2014-02-17 10:18:15 +00:00
|
|
|
#include "VideoCommon/VideoConfig.h"
|
2010-10-19 22:24:27 +00:00
|
|
|
|
2014-05-19 16:27:59 +00:00
|
|
|
static const u64 TEXHASH_INVALID = 0;
|
2017-03-22 08:15:09 +00:00
|
|
|
// Sonic the Fighters (inside Sonic Gems Collection) loops a 64 frames animation
|
|
|
|
static const int TEXTURE_KILL_THRESHOLD = 64;
|
2015-01-17 09:29:10 +00:00
|
|
|
static const int TEXTURE_POOL_KILL_THRESHOLD = 3;
|
2010-10-19 22:24:27 +00:00
|
|
|
|
2015-12-21 02:49:49 +00:00
|
|
|
std::unique_ptr<TextureCacheBase> g_texture_cache;
|
2010-10-19 22:24:27 +00:00
|
|
|
|
2017-06-29 21:09:32 +00:00
|
|
|
std::bitset<8> TextureCacheBase::valid_bind_points;
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
TextureCacheBase::TCacheEntry::TCacheEntry(std::unique_ptr<AbstractTexture> tex)
|
|
|
|
: texture(std::move(tex))
|
2010-10-19 22:24:27 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
TextureCacheBase::TCacheEntry::~TCacheEntry()
|
2017-04-28 14:53:32 +00:00
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
for (auto& reference : references)
|
|
|
|
reference->references.erase(this);
|
2017-04-28 14:53:32 +00:00
|
|
|
}
|
|
|
|
|
2015-11-06 00:28:05 +00:00
|
|
|
void TextureCacheBase::CheckTempSize(size_t required_size)
|
2014-12-22 11:53:03 +00:00
|
|
|
{
|
2016-06-24 08:43:46 +00:00
|
|
|
if (required_size <= temp_size)
|
|
|
|
return;
|
2014-12-22 11:53:03 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
temp_size = required_size;
|
2016-08-07 17:03:07 +00:00
|
|
|
Common::FreeAlignedMemory(temp);
|
|
|
|
temp = static_cast<u8*>(Common::AllocateAlignedMemory(temp_size, 16));
|
2014-12-22 11:53:03 +00:00
|
|
|
}
|
|
|
|
|
2015-11-06 00:28:05 +00:00
|
|
|
TextureCacheBase::TextureCacheBase()
|
2010-10-19 22:24:27 +00:00
|
|
|
{
|
2016-09-06 22:57:58 +00:00
|
|
|
SetBackupConfig(g_ActiveConfig);
|
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
temp_size = 2048 * 2048 * 4;
|
2016-09-06 22:57:58 +00:00
|
|
|
temp = static_cast<u8*>(Common::AllocateAlignedMemory(temp_size, 16));
|
2013-04-24 13:21:54 +00:00
|
|
|
|
2016-09-06 22:57:58 +00:00
|
|
|
TexDecoder_SetTexFmtOverlayOptions(backup_config.texfmt_overlay,
|
|
|
|
backup_config.texfmt_overlay_center);
|
2013-04-24 13:21:54 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
HiresTexture::Init();
|
2013-04-24 13:21:54 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
SetHash64Function();
|
2017-06-29 21:09:32 +00:00
|
|
|
|
|
|
|
InvalidateAllBindPoints();
|
2010-10-19 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
2015-11-06 00:28:05 +00:00
|
|
|
void TextureCacheBase::Invalidate()
|
2010-10-19 22:24:27 +00:00
|
|
|
{
|
2017-06-29 21:09:32 +00:00
|
|
|
InvalidateAllBindPoints();
|
|
|
|
for (size_t i = 0; i < bound_textures.size(); ++i)
|
|
|
|
{
|
|
|
|
bound_textures[i] = nullptr;
|
|
|
|
}
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
for (auto& tex : textures_by_address)
|
|
|
|
{
|
|
|
|
delete tex.second;
|
|
|
|
}
|
|
|
|
textures_by_address.clear();
|
|
|
|
textures_by_hash.clear();
|
|
|
|
|
|
|
|
texture_pool.clear();
|
2010-10-19 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
2015-11-06 00:28:05 +00:00
|
|
|
TextureCacheBase::~TextureCacheBase()
|
2010-10-19 22:24:27 +00:00
|
|
|
{
|
2016-06-24 08:43:46 +00:00
|
|
|
HiresTexture::Shutdown();
|
|
|
|
Invalidate();
|
2016-08-07 17:03:07 +00:00
|
|
|
Common::FreeAlignedMemory(temp);
|
2016-06-24 08:43:46 +00:00
|
|
|
temp = nullptr;
|
2010-10-19 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
2015-11-06 00:28:05 +00:00
|
|
|
void TextureCacheBase::OnConfigChanged(VideoConfig& config)
|
2012-05-28 09:31:37 +00:00
|
|
|
{
|
2016-09-06 22:57:58 +00:00
|
|
|
if (config.bHiresTextures != backup_config.hires_textures ||
|
|
|
|
config.bCacheHiresTextures != backup_config.cache_hires_textures)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2016-09-06 22:57:58 +00:00
|
|
|
HiresTexture::Update();
|
|
|
|
}
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2016-09-06 22:57:58 +00:00
|
|
|
// 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 ||
|
2016-11-27 08:14:59 +00:00
|
|
|
config.bHiresTextures != backup_config.hires_textures ||
|
|
|
|
config.bEnableGPUTextureDecoding != backup_config.gpu_texture_decoding)
|
2016-09-06 22:57:58 +00:00
|
|
|
{
|
|
|
|
Invalidate();
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2016-09-06 22:57:58 +00:00
|
|
|
TexDecoder_SetTexFmtOverlayOptions(g_ActiveConfig.bTexFmtOverlayEnable,
|
|
|
|
g_ActiveConfig.bTexFmtOverlayCenter);
|
|
|
|
}
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2016-09-06 22:57:58 +00:00
|
|
|
if ((config.iStereoMode > 0) != backup_config.stereo_3d ||
|
|
|
|
config.bStereoEFBMonoDepth != backup_config.efb_mono_depth)
|
|
|
|
{
|
|
|
|
g_texture_cache->DeleteShaders();
|
|
|
|
if (!g_texture_cache->CompileShaders())
|
|
|
|
PanicAlert("Failed to recompile one or more texture conversion shaders.");
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
|
2016-09-06 22:57:58 +00:00
|
|
|
SetBackupConfig(config);
|
2012-05-28 09:31:37 +00:00
|
|
|
}
|
|
|
|
|
2015-11-06 00:28:05 +00:00
|
|
|
void TextureCacheBase::Cleanup(int _frameCount)
|
2010-10-19 22:24:27 +00:00
|
|
|
{
|
2016-12-25 17:48:19 +00:00
|
|
|
TexAddrCache::iterator iter = textures_by_address.begin();
|
|
|
|
TexAddrCache::iterator tcend = textures_by_address.end();
|
2016-06-24 08:43:46 +00:00
|
|
|
while (iter != tcend)
|
|
|
|
{
|
2017-06-29 21:09:32 +00:00
|
|
|
if (iter->second->tmem_only)
|
|
|
|
{
|
|
|
|
iter = InvalidateTexture(iter);
|
|
|
|
}
|
|
|
|
else if (iter->second->frameCount == FRAMECOUNT_INVALID)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
|
|
|
iter->second->frameCount = _frameCount;
|
|
|
|
++iter;
|
|
|
|
}
|
|
|
|
else if (_frameCount > TEXTURE_KILL_THRESHOLD + iter->second->frameCount)
|
|
|
|
{
|
2017-06-26 17:06:50 +00:00
|
|
|
if (iter->second->IsCopy())
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
|
|
|
// Only remove EFB copies when they wouldn't be used anymore(changed hash), because EFB
|
|
|
|
// copies living on the
|
|
|
|
// host GPU are unrecoverable. Perform this check only every TEXTURE_KILL_THRESHOLD for
|
|
|
|
// performance reasons
|
|
|
|
if ((_frameCount - iter->second->frameCount) % TEXTURE_KILL_THRESHOLD == 1 &&
|
|
|
|
iter->second->hash != iter->second->CalculateHash())
|
|
|
|
{
|
|
|
|
iter = InvalidateTexture(iter);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
++iter;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
iter = InvalidateTexture(iter);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
++iter;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
TexPool::iterator iter2 = texture_pool.begin();
|
|
|
|
TexPool::iterator tcend2 = texture_pool.end();
|
|
|
|
while (iter2 != tcend2)
|
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
if (iter2->second.frameCount == FRAMECOUNT_INVALID)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
iter2->second.frameCount = _frameCount;
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
2017-04-23 04:44:34 +00:00
|
|
|
if (_frameCount > TEXTURE_POOL_KILL_THRESHOLD + iter2->second.frameCount)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
|
|
|
iter2 = texture_pool.erase(iter2);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
++iter2;
|
|
|
|
}
|
|
|
|
}
|
2010-10-19 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
bool TextureCacheBase::TCacheEntry::OverlapsMemoryRange(u32 range_address, u32 range_size) const
|
2010-10-19 22:24:27 +00:00
|
|
|
{
|
2016-06-24 08:43:46 +00:00
|
|
|
if (addr + size_in_bytes <= range_address)
|
|
|
|
return false;
|
2010-10-19 22:24:27 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
if (addr >= range_address + range_size)
|
|
|
|
return false;
|
2012-03-20 21:36:21 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
return true;
|
2010-10-19 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
2016-09-06 22:57:58 +00:00
|
|
|
void TextureCacheBase::SetBackupConfig(const VideoConfig& config)
|
2016-03-26 02:43:32 +00:00
|
|
|
{
|
2016-09-06 22:57:58 +00:00
|
|
|
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.iStereoMode > 0;
|
|
|
|
backup_config.efb_mono_depth = config.bStereoEFBMonoDepth;
|
2016-11-27 08:14:59 +00:00
|
|
|
backup_config.gpu_texture_decoding = config.bEnableGPUTextureDecoding;
|
2016-09-06 22:57:58 +00:00
|
|
|
}
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
TextureCacheBase::TCacheEntry*
|
|
|
|
TextureCacheBase::ApplyPaletteToEntry(TCacheEntry* entry, u8* palette, TLUTFormat tlutfmt)
|
2016-09-06 22:57:58 +00:00
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
TextureConfig new_config = entry->texture->GetConfig();
|
2016-09-06 22:57:58 +00:00
|
|
|
new_config.levels = 1;
|
|
|
|
new_config.rendertarget = true;
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
TCacheEntry* decoded_entry = AllocateCacheEntry(new_config);
|
2016-09-06 22:57:58 +00:00
|
|
|
if (!decoded_entry)
|
|
|
|
return nullptr;
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
decoded_entry->SetGeneralParameters(entry->addr, entry->size_in_bytes, entry->format,
|
|
|
|
entry->should_force_safe_hashing);
|
2016-09-06 22:57:58 +00:00
|
|
|
decoded_entry->SetDimensions(entry->native_width, entry->native_height, 1);
|
|
|
|
decoded_entry->SetHashes(entry->base_hash, entry->hash);
|
|
|
|
decoded_entry->frameCount = FRAMECOUNT_INVALID;
|
2017-06-26 17:06:50 +00:00
|
|
|
decoded_entry->should_force_safe_hashing = false;
|
|
|
|
decoded_entry->SetNotCopy();
|
2017-06-28 14:25:01 +00:00
|
|
|
decoded_entry->may_have_overlapping_textures = entry->may_have_overlapping_textures;
|
2016-09-06 22:57:58 +00:00
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
ConvertTexture(decoded_entry, entry, palette, tlutfmt);
|
2016-09-06 22:57:58 +00:00
|
|
|
textures_by_address.emplace(entry->addr, decoded_entry);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2016-09-06 22:57:58 +00:00
|
|
|
return decoded_entry;
|
2016-03-26 02:43:32 +00:00
|
|
|
}
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
void TextureCacheBase::ScaleTextureCacheEntryTo(TextureCacheBase::TCacheEntry* entry, u32 new_width,
|
|
|
|
u32 new_height)
|
2015-12-18 15:59:11 +00:00
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
if (entry->GetWidth() == new_width && entry->GetHeight() == new_height)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-03-09 14:01:23 +00:00
|
|
|
const u32 max = g_ActiveConfig.backend_info.MaxTextureSize;
|
2016-06-24 08:43:46 +00:00
|
|
|
if (max < new_width || max < new_height)
|
|
|
|
{
|
|
|
|
ERROR_LOG(VIDEO, "Texture too big, width = %d, height = %d", new_width, new_height);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
TextureConfig newconfig;
|
2016-06-24 08:43:46 +00:00
|
|
|
newconfig.width = new_width;
|
|
|
|
newconfig.height = new_height;
|
2017-04-23 04:44:34 +00:00
|
|
|
newconfig.layers = entry->GetNumLayers();
|
2016-06-24 08:43:46 +00:00
|
|
|
newconfig.rendertarget = true;
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
std::unique_ptr<AbstractTexture> new_texture = AllocateTexture(newconfig);
|
|
|
|
if (new_texture)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
new_texture->CopyRectangleFromTexture(entry->texture.get(),
|
|
|
|
entry->texture->GetConfig().GetRect(),
|
|
|
|
new_texture->GetConfig().GetRect());
|
|
|
|
entry->texture.swap(new_texture);
|
|
|
|
|
|
|
|
auto config = new_texture->GetConfig();
|
|
|
|
// 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
|
|
|
|
texture_pool.emplace(config, TexPoolEntry(std::move(new_texture)));
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ERROR_LOG(VIDEO, "Scaling failed");
|
|
|
|
}
|
2015-12-18 15:59:11 +00:00
|
|
|
}
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
TextureCacheBase::TCacheEntry*
|
2017-07-30 19:45:55 +00:00
|
|
|
TextureCacheBase::DoPartialTextureUpdates(TCacheEntry* entry_to_update, u8* palette,
|
|
|
|
TLUTFormat tlutfmt)
|
2015-06-13 13:51:58 +00:00
|
|
|
{
|
2016-12-26 17:41:34 +00:00
|
|
|
// If the flag may_have_overlapping_textures is cleared, there are no overlapping EFB copies,
|
|
|
|
// which aren't applied already. It is set for new textures, and for the affected range
|
|
|
|
// on each EFB copy.
|
|
|
|
if (!entry_to_update->may_have_overlapping_textures)
|
|
|
|
return entry_to_update;
|
|
|
|
entry_to_update->may_have_overlapping_textures = false;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
const bool isPaletteTexture = IsColorIndexed(entry_to_update->format.texfmt);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
// EFB copies are excluded from these updates, until there's an example where a game would
|
|
|
|
// benefit from updating. This would require more work to be done.
|
2017-06-26 17:06:50 +00:00
|
|
|
if (entry_to_update->IsCopy())
|
2016-06-24 08:43:46 +00:00
|
|
|
return entry_to_update;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
u32 block_width = TexDecoder_GetBlockWidthInTexels(entry_to_update->format.texfmt);
|
|
|
|
u32 block_height = TexDecoder_GetBlockHeightInTexels(entry_to_update->format.texfmt);
|
2016-06-24 08:43:46 +00:00
|
|
|
u32 block_size = block_width * block_height *
|
2017-07-30 19:45:55 +00:00
|
|
|
TexDecoder_GetTexelSizeInNibbles(entry_to_update->format.texfmt) / 2;
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
u32 numBlocksX = (entry_to_update->native_width + block_width - 1) / block_width;
|
|
|
|
|
2016-12-26 17:41:34 +00:00
|
|
|
auto iter = FindOverlappingTextures(entry_to_update->addr, entry_to_update->size_in_bytes);
|
|
|
|
while (iter.first != iter.second)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
TCacheEntry* entry = iter.first->second;
|
2017-06-26 17:06:50 +00:00
|
|
|
if (entry != entry_to_update && entry->IsCopy() && !entry->tmem_only &&
|
2016-06-24 08:43:46 +00:00
|
|
|
entry->references.count(entry_to_update) == 0 &&
|
|
|
|
entry->OverlapsMemoryRange(entry_to_update->addr, entry_to_update->size_in_bytes) &&
|
|
|
|
entry->memory_stride == numBlocksX * block_size)
|
|
|
|
{
|
|
|
|
if (entry->hash == entry->CalculateHash())
|
|
|
|
{
|
|
|
|
if (isPaletteTexture)
|
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
TCacheEntry* decoded_entry = ApplyPaletteToEntry(entry, palette, tlutfmt);
|
2016-06-24 08:43:46 +00:00
|
|
|
if (decoded_entry)
|
|
|
|
{
|
|
|
|
// Link the efb copy with the partially updated texture, so we won't apply this partial
|
|
|
|
// update again
|
|
|
|
entry->CreateReference(entry_to_update);
|
|
|
|
// Mark the texture update as used, as if it was loaded directly
|
|
|
|
entry->frameCount = FRAMECOUNT_INVALID;
|
|
|
|
entry = decoded_entry;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-12-26 17:41:34 +00:00
|
|
|
++iter.first;
|
2016-06-24 08:43:46 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 src_x, src_y, dst_x, dst_y;
|
|
|
|
|
|
|
|
// Note for understanding the math:
|
|
|
|
// Normal textures can't be strided, so the 2 missing cases with src_x > 0 don't exist
|
|
|
|
if (entry->addr >= entry_to_update->addr)
|
|
|
|
{
|
|
|
|
u32 block_offset = (entry->addr - entry_to_update->addr) / block_size;
|
|
|
|
u32 block_x = block_offset % numBlocksX;
|
|
|
|
u32 block_y = block_offset / numBlocksX;
|
|
|
|
src_x = 0;
|
|
|
|
src_y = 0;
|
|
|
|
dst_x = block_x * block_width;
|
|
|
|
dst_y = block_y * block_height;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
u32 block_offset = (entry_to_update->addr - entry->addr) / block_size;
|
|
|
|
u32 block_x = (~block_offset + 1) % numBlocksX;
|
|
|
|
u32 block_y = (block_offset + block_x) / numBlocksX;
|
|
|
|
src_x = 0;
|
|
|
|
src_y = block_y * block_height;
|
|
|
|
dst_x = block_x * block_width;
|
|
|
|
dst_y = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 copy_width =
|
|
|
|
std::min(entry->native_width - src_x, entry_to_update->native_width - dst_x);
|
|
|
|
u32 copy_height =
|
2017-07-03 02:24:20 +00:00
|
|
|
std::min((entry->native_height * entry->y_scale) - src_y, (entry_to_update->native_height * entry_to_update->y_scale) - dst_y);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
// If one of the textures is scaled, scale both with the current efb scaling factor
|
2017-04-23 04:44:34 +00:00
|
|
|
if (entry_to_update->native_width != entry_to_update->GetWidth() ||
|
|
|
|
entry_to_update->native_height != entry_to_update->GetHeight() ||
|
|
|
|
entry->native_width != entry->GetWidth() || entry->native_height != entry->GetHeight())
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
ScaleTextureCacheEntryTo(entry_to_update,
|
2017-03-04 06:39:50 +00:00
|
|
|
g_renderer->EFBToScaledX(entry_to_update->native_width),
|
2017-07-03 02:24:20 +00:00
|
|
|
g_renderer->EFBToScaledY(entry_to_update->native_height * entry_to_update->y_scale));
|
2017-04-23 04:44:34 +00:00
|
|
|
ScaleTextureCacheEntryTo(entry, g_renderer->EFBToScaledX(entry->native_width),
|
2017-07-03 02:24:20 +00:00
|
|
|
g_renderer->EFBToScaledY(entry->native_height * entry->y_scale));
|
2017-03-04 06:39:50 +00:00
|
|
|
|
|
|
|
src_x = g_renderer->EFBToScaledX(src_x);
|
|
|
|
src_y = g_renderer->EFBToScaledY(src_y);
|
|
|
|
dst_x = g_renderer->EFBToScaledX(dst_x);
|
|
|
|
dst_y = g_renderer->EFBToScaledY(dst_y);
|
|
|
|
copy_width = g_renderer->EFBToScaledX(copy_width);
|
|
|
|
copy_height = g_renderer->EFBToScaledY(copy_height);
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
MathUtil::Rectangle<int> srcrect, dstrect;
|
|
|
|
srcrect.left = src_x;
|
|
|
|
srcrect.top = src_y;
|
|
|
|
srcrect.right = (src_x + copy_width);
|
|
|
|
srcrect.bottom = (src_y + copy_height);
|
|
|
|
dstrect.left = dst_x;
|
|
|
|
dstrect.top = dst_y;
|
|
|
|
dstrect.right = (dst_x + copy_width);
|
|
|
|
dstrect.bottom = (dst_y + copy_height);
|
2017-04-23 04:44:34 +00:00
|
|
|
entry_to_update->texture->CopyRectangleFromTexture(entry->texture.get(), srcrect, dstrect);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
if (isPaletteTexture)
|
|
|
|
{
|
|
|
|
// Remove the temporary converted texture, it won't be used anywhere else
|
|
|
|
// TODO: It would be nice to convert and copy in one step, but this code path isn't common
|
|
|
|
InvalidateTexture(GetTexCacheIter(entry));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Link the two textures together, so we won't apply this partial update again
|
|
|
|
entry->CreateReference(entry_to_update);
|
|
|
|
// Mark the texture update as used, as if it was loaded directly
|
|
|
|
entry->frameCount = FRAMECOUNT_INVALID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// If the hash does not match, this EFB copy will not be used for anything, so remove it
|
2016-12-26 17:41:34 +00:00
|
|
|
iter.first = InvalidateTexture(iter.first);
|
2016-06-24 08:43:46 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2016-12-26 17:41:34 +00:00
|
|
|
++iter.first;
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
return entry_to_update;
|
2015-06-13 13:51:58 +00:00
|
|
|
}
|
|
|
|
|
2017-10-18 09:02:56 +00:00
|
|
|
void TextureCacheBase::DumpTexture(TCacheEntry* entry, std::string basename, unsigned int level,
|
|
|
|
bool is_arbitrary)
|
2012-05-12 11:25:13 +00:00
|
|
|
{
|
2017-03-09 08:47:43 +00:00
|
|
|
std::string szDir = File::GetUserPath(D_DUMPTEXTURES_IDX) + SConfig::GetInstance().GetGameID();
|
2012-05-12 11:31:09 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
// make sure that the directory exists
|
2017-06-29 09:20:38 +00:00
|
|
|
if (!File::IsDirectory(szDir))
|
2016-06-24 08:43:46 +00:00
|
|
|
File::CreateDir(szDir);
|
2012-05-12 11:31:09 +00:00
|
|
|
|
2017-11-02 04:38:36 +00:00
|
|
|
if (is_arbitrary)
|
|
|
|
{
|
|
|
|
basename += "_arb";
|
|
|
|
}
|
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
if (level > 0)
|
|
|
|
{
|
2017-11-02 04:38:36 +00:00
|
|
|
basename += StringFromFormat("_mip%i", level);
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
2017-10-18 09:02:56 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
std::string filename = szDir + "/" + basename + ".png";
|
2012-05-12 11:31:09 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
if (!File::Exists(filename))
|
2017-04-23 04:44:34 +00:00
|
|
|
entry->texture->Save(filename, level);
|
2012-05-12 11:31:09 +00:00
|
|
|
}
|
|
|
|
|
2013-02-16 02:46:03 +00:00
|
|
|
static u32 CalculateLevelSize(u32 level_0_size, u32 level)
|
|
|
|
{
|
2016-06-24 08:43:46 +00:00
|
|
|
return std::max(level_0_size >> level, 1u);
|
2013-02-16 02:46:03 +00:00
|
|
|
}
|
|
|
|
|
2015-11-06 00:28:05 +00:00
|
|
|
void TextureCacheBase::BindTextures()
|
2015-01-26 23:33:23 +00:00
|
|
|
{
|
2017-03-25 18:45:55 +00:00
|
|
|
for (size_t i = 0; i < bound_textures.size(); ++i)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2017-06-29 21:09:32 +00:00
|
|
|
if (IsValidBindPoint(static_cast<u32>(i)) && bound_textures[i])
|
2017-04-23 04:44:34 +00:00
|
|
|
bound_textures[i]->texture->Bind(static_cast<u32>(i));
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
2015-01-26 23:33:23 +00:00
|
|
|
}
|
|
|
|
|
2017-10-18 09:02:56 +00:00
|
|
|
class ArbitraryMipmapDetector
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
using PixelRGBAf = std::array<float, 4>;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit ArbitraryMipmapDetector() = default;
|
|
|
|
|
|
|
|
void AddLevel(u32 width, u32 height, u32 row_length, const u8* buffer)
|
|
|
|
{
|
|
|
|
levels.push_back({width, height, row_length, buffer});
|
|
|
|
}
|
|
|
|
|
|
|
|
bool HasArbitraryMipmaps(u8* downsample_buffer) const
|
|
|
|
{
|
|
|
|
if (levels.size() < 2)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// This is the average per-pixel, per-channel difference in percent between what we
|
|
|
|
// expect a normal blurred mipmap to look like and what we actually received
|
2017-11-02 04:38:36 +00:00
|
|
|
// 4.5% was chosen because it's just below the lowest clearly-arbitrary texture
|
|
|
|
// I found in my tests, the background clouds in Mario Galaxy's Observatory lobby.
|
|
|
|
constexpr auto THRESHOLD_PERCENT = 4.5f;
|
|
|
|
|
|
|
|
auto* src = downsample_buffer;
|
|
|
|
auto* dst = downsample_buffer + levels[1].shape.row_length * levels[1].shape.height * 4;
|
|
|
|
|
|
|
|
float total_diff = 0.f;
|
2017-10-18 09:02:56 +00:00
|
|
|
|
|
|
|
for (std::size_t i = 0; i < levels.size() - 1; ++i)
|
|
|
|
{
|
|
|
|
const auto& level = levels[i];
|
|
|
|
const auto& mip = levels[i + 1];
|
|
|
|
|
2017-11-02 04:38:36 +00:00
|
|
|
// Manually downsample the past downsample with a simple box blur
|
2017-10-18 09:02:56 +00:00
|
|
|
// This is not necessarily close to whatever the original artists used, however
|
|
|
|
// It should still be closer than a thing that's not a downscale at all
|
2017-11-02 04:38:36 +00:00
|
|
|
Level::Downsample(i ? src : level.pixels, level.shape, dst, mip.shape);
|
2017-10-18 09:02:56 +00:00
|
|
|
|
|
|
|
// Find the average difference between pixels in this level but downsampled
|
|
|
|
// and the next level
|
2017-11-02 04:38:36 +00:00
|
|
|
auto diff = mip.AverageDiff(dst);
|
|
|
|
total_diff += diff;
|
|
|
|
|
|
|
|
std::swap(src, dst);
|
2017-10-18 09:02:56 +00:00
|
|
|
}
|
2017-11-02 04:38:36 +00:00
|
|
|
|
|
|
|
auto all_levels = total_diff / (levels.size() - 1);
|
|
|
|
return all_levels > THRESHOLD_PERCENT;
|
2017-10-18 09:02:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
static float SRGBToLinear(u8 srgb_byte)
|
|
|
|
{
|
|
|
|
auto srgb_float = static_cast<float>(srgb_byte) / 256.f;
|
|
|
|
// approximations found on
|
|
|
|
// http://chilliant.blogspot.com/2012/08/srgb-approximations-for-hlsl.html
|
|
|
|
return srgb_float * (srgb_float * (srgb_float * 0.305306011f + 0.682171111f) + 0.012522878f);
|
|
|
|
}
|
|
|
|
|
|
|
|
static u8 LinearToSRGB(float linear)
|
|
|
|
{
|
|
|
|
return static_cast<u8>(std::max(1.055f * std::pow(linear, 0.416666667f) - 0.055f, 0.f) * 256.f);
|
|
|
|
}
|
|
|
|
|
2017-11-02 04:38:36 +00:00
|
|
|
struct Shape
|
2017-10-18 09:02:56 +00:00
|
|
|
{
|
|
|
|
u32 width;
|
|
|
|
u32 height;
|
|
|
|
u32 row_length;
|
2017-11-02 04:38:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct Level
|
|
|
|
{
|
|
|
|
Shape shape;
|
|
|
|
const u8* pixels;
|
2017-10-18 09:02:56 +00:00
|
|
|
|
2017-11-02 04:38:36 +00:00
|
|
|
static PixelRGBAf Sample(const u8* src, const Shape& src_shape, u32 x, u32 y)
|
2017-10-18 09:02:56 +00:00
|
|
|
{
|
2017-11-02 04:38:36 +00:00
|
|
|
const auto* p = src + (x + y * src_shape.row_length) * 4;
|
2017-10-18 09:02:56 +00:00
|
|
|
return {SRGBToLinear(p[0]), SRGBToLinear(p[1]), SRGBToLinear(p[2]), SRGBToLinear(p[3])};
|
|
|
|
}
|
|
|
|
|
|
|
|
// Puts a downsampled image in dst. dst must be at least width*height*4
|
2017-11-02 04:38:36 +00:00
|
|
|
static void Downsample(const u8* src, const Shape& src_shape, u8* dst, const Shape& dst_shape)
|
2017-10-18 09:02:56 +00:00
|
|
|
{
|
|
|
|
for (u32 i = 0; i < dst_shape.height; ++i)
|
|
|
|
{
|
|
|
|
for (u32 j = 0; j < dst_shape.width; ++j)
|
|
|
|
{
|
|
|
|
auto x = j * 2;
|
|
|
|
auto y = i * 2;
|
2017-11-02 04:38:36 +00:00
|
|
|
const std::array<PixelRGBAf, 4> samples = {
|
|
|
|
Sample(src, src_shape, x, y), Sample(src, src_shape, x + 1, y),
|
|
|
|
Sample(src, src_shape, x, y + 1), Sample(src, src_shape, x + 1, y + 1)};
|
|
|
|
|
2017-10-18 09:02:56 +00:00
|
|
|
auto* dst_pixel = dst + (j + i * dst_shape.row_length) * 4;
|
|
|
|
dst_pixel[0] =
|
2017-11-02 04:38:36 +00:00
|
|
|
LinearToSRGB((samples[0][0] + samples[1][0] + samples[2][0] + samples[3][0]) * 0.25f);
|
2017-10-18 09:02:56 +00:00
|
|
|
dst_pixel[1] =
|
2017-11-02 04:38:36 +00:00
|
|
|
LinearToSRGB((samples[0][1] + samples[1][1] + samples[2][1] + samples[3][1]) * 0.25f);
|
2017-10-18 09:02:56 +00:00
|
|
|
dst_pixel[2] =
|
2017-11-02 04:38:36 +00:00
|
|
|
LinearToSRGB((samples[0][2] + samples[1][2] + samples[2][2] + samples[3][2]) * 0.25f);
|
2017-10-18 09:02:56 +00:00
|
|
|
dst_pixel[3] =
|
2017-11-02 04:38:36 +00:00
|
|
|
LinearToSRGB((samples[0][3] + samples[1][3] + samples[2][3] + samples[3][3]) * 0.25f);
|
2017-10-18 09:02:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
float AverageDiff(const u8* other) const
|
|
|
|
{
|
|
|
|
float average_diff = 0.f;
|
2017-11-02 04:38:36 +00:00
|
|
|
const auto* ptr1 = pixels;
|
2017-10-18 09:02:56 +00:00
|
|
|
const auto* ptr2 = other;
|
2017-11-02 04:38:36 +00:00
|
|
|
for (u32 i = 0; i < shape.height; ++i)
|
2017-10-18 09:02:56 +00:00
|
|
|
{
|
|
|
|
const auto* row1 = ptr1;
|
|
|
|
const auto* row2 = ptr2;
|
2017-11-02 04:38:36 +00:00
|
|
|
for (u32 j = 0; j < shape.width; ++j, row1 += 4, row2 += 4)
|
2017-10-18 09:02:56 +00:00
|
|
|
{
|
2017-11-02 04:38:36 +00:00
|
|
|
average_diff += std::abs(static_cast<float>(row1[0]) - static_cast<float>(row2[0]));
|
|
|
|
average_diff += std::abs(static_cast<float>(row1[1]) - static_cast<float>(row2[1]));
|
|
|
|
average_diff += std::abs(static_cast<float>(row1[2]) - static_cast<float>(row2[2]));
|
|
|
|
average_diff += std::abs(static_cast<float>(row1[3]) - static_cast<float>(row2[3]));
|
2017-10-18 09:02:56 +00:00
|
|
|
}
|
2017-11-02 04:38:36 +00:00
|
|
|
ptr1 += shape.row_length;
|
|
|
|
ptr2 += shape.row_length;
|
2017-10-18 09:02:56 +00:00
|
|
|
}
|
|
|
|
|
2017-11-02 04:38:36 +00:00
|
|
|
return average_diff / (shape.width * shape.height * 4) / 2.56f;
|
2017-10-18 09:02:56 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
std::vector<Level> levels;
|
|
|
|
};
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
TextureCacheBase::TCacheEntry* TextureCacheBase::Load(const u32 stage)
|
2010-10-19 22:24:27 +00:00
|
|
|
{
|
2017-06-29 21:09:32 +00:00
|
|
|
// if this stage was not invalidated by changes to texture registers, keep the current texture
|
|
|
|
if (IsValidBindPoint(stage) && bound_textures[stage])
|
|
|
|
{
|
2017-05-29 22:02:09 +00:00
|
|
|
return bound_textures[stage];
|
2017-06-29 21:09:32 +00:00
|
|
|
}
|
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
const FourTexUnits& tex = bpmem.tex[stage >> 2];
|
|
|
|
const u32 id = stage & 3;
|
|
|
|
const u32 address = (tex.texImage3[id].image_base /* & 0x1FFFFF*/) << 5;
|
|
|
|
u32 width = tex.texImage0[id].width + 1;
|
|
|
|
u32 height = tex.texImage0[id].height + 1;
|
2017-07-30 19:45:55 +00:00
|
|
|
const TextureFormat texformat = static_cast<TextureFormat>(tex.texImage0[id].format);
|
2016-06-24 08:43:46 +00:00
|
|
|
const u32 tlutaddr = tex.texTlut[id].tmem_offset << 9;
|
2017-07-30 19:45:55 +00:00
|
|
|
const TLUTFormat tlutfmt = static_cast<TLUTFormat>(tex.texTlut[id].tlut_format);
|
2016-06-24 08:43:46 +00:00
|
|
|
const bool use_mipmaps = SamplerCommon::AreBpTexMode0MipmapsEnabled(tex.texMode0[id]);
|
|
|
|
u32 tex_levels = use_mipmaps ? ((tex.texMode1[id].max_lod + 0xf) / 0x10 + 1) : 1;
|
|
|
|
const bool from_tmem = tex.texImage1[id].image_type != 0;
|
2017-05-29 22:02:09 +00:00
|
|
|
const u32 tmem_address_even = from_tmem ? tex.texImage1[id].tmem_even * TMEM_LINE_SIZE : 0;
|
|
|
|
const u32 tmem_address_odd = from_tmem ? tex.texImage2[id].tmem_odd * TMEM_LINE_SIZE : 0;
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
auto entry = GetTexture(address, width, height, texformat,
|
|
|
|
g_ActiveConfig.iSafeTextureCache_ColorSamples, tlutaddr, tlutfmt,
|
|
|
|
use_mipmaps, tex_levels, from_tmem, tmem_address_even,
|
|
|
|
tmem_address_odd);
|
|
|
|
|
|
|
|
if (!entry)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
entry->frameCount = FRAMECOUNT_INVALID;
|
|
|
|
bound_textures[stage] = entry;
|
|
|
|
|
|
|
|
GFX_DEBUGGER_PAUSE_AT(NEXT_TEXTURE_CHANGE, true);
|
|
|
|
|
|
|
|
// We need to keep track of invalided textures until they have actually been replaced or re-loaded
|
|
|
|
valid_bind_points.set(stage);
|
|
|
|
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
TextureCacheBase::TCacheEntry* TextureCacheBase::GetTexture(u32 address, u32 width, u32 height,
|
|
|
|
const TextureFormat texformat,
|
|
|
|
const int textureCacheSafetyColorSampleSize, u32 tlutaddr,
|
|
|
|
TLUTFormat tlutfmt, bool use_mipmaps,
|
|
|
|
u32 tex_levels, bool from_tmem, u32 tmem_address_even,
|
|
|
|
u32 tmem_address_odd)
|
|
|
|
{
|
2016-06-24 08:43:46 +00:00
|
|
|
// TexelSizeInNibbles(format) * width * height / 16;
|
|
|
|
const unsigned int bsw = TexDecoder_GetBlockWidthInTexels(texformat);
|
|
|
|
const unsigned int bsh = TexDecoder_GetBlockHeightInTexels(texformat);
|
|
|
|
|
2016-11-27 10:56:22 +00:00
|
|
|
unsigned int expandedWidth = Common::AlignUp(width, bsw);
|
|
|
|
unsigned int expandedHeight = Common::AlignUp(height, bsh);
|
2016-06-24 08:43:46 +00:00
|
|
|
const unsigned int nativeW = width;
|
|
|
|
const unsigned int nativeH = height;
|
|
|
|
|
|
|
|
// Hash assigned to texcache entry (also used to generate filenames used for texture dumping and
|
|
|
|
// custom texture lookup)
|
|
|
|
u64 base_hash = TEXHASH_INVALID;
|
|
|
|
u64 full_hash = TEXHASH_INVALID;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
TextureAndTLUTFormat full_format(texformat, tlutfmt);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
const bool isPaletteTexture = IsColorIndexed(texformat);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
// Reject invalid tlut format.
|
2017-07-30 19:45:55 +00:00
|
|
|
if (isPaletteTexture && !IsValidTLUTFormat(tlutfmt))
|
2016-06-24 08:43:46 +00:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
const u32 texture_size =
|
|
|
|
TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, texformat);
|
2016-11-27 08:14:59 +00:00
|
|
|
u32 bytes_per_block = (bsw * bsh * TexDecoder_GetTexelSizeInNibbles(texformat)) / 2;
|
2016-06-24 08:43:46 +00:00
|
|
|
u32 additional_mips_size = 0; // not including level 0, which is texture_size
|
|
|
|
|
|
|
|
// GPUs don't like when the specified mipmap count would require more than one 1x1-sized LOD in
|
|
|
|
// the mipmap chain
|
|
|
|
// e.g. 64x64 with 7 LODs would have the mipmap chain 64x64,32x32,16x16,8x8,4x4,2x2,1x1,0x0, so we
|
|
|
|
// limit the mipmap count to 6 there
|
|
|
|
tex_levels = std::min<u32>(IntLog2(std::max(width, height)) + 1, tex_levels);
|
|
|
|
|
|
|
|
for (u32 level = 1; level != tex_levels; ++level)
|
|
|
|
{
|
|
|
|
// We still need to calculate the original size of the mips
|
2016-11-27 10:56:22 +00:00
|
|
|
const u32 expanded_mip_width = Common::AlignUp(CalculateLevelSize(width, level), bsw);
|
|
|
|
const u32 expanded_mip_height = Common::AlignUp(CalculateLevelSize(height, level), bsh);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
additional_mips_size +=
|
|
|
|
TexDecoder_GetTextureSizeInBytes(expanded_mip_width, expanded_mip_height, texformat);
|
|
|
|
}
|
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
// TODO: the texture cache lookup is based on address, but a texture from tmem has no reason
|
|
|
|
// to have a unique and valid address. This could result in a regular texture and a tmem
|
|
|
|
// texture aliasing onto the same texture cache entry.
|
2016-06-24 08:43:46 +00:00
|
|
|
const u8* src_data;
|
|
|
|
if (from_tmem)
|
2017-05-29 22:02:09 +00:00
|
|
|
src_data = &texMem[tmem_address_even];
|
2016-06-24 08:43:46 +00:00
|
|
|
else
|
|
|
|
src_data = Memory::GetPointer(address);
|
|
|
|
|
|
|
|
if (!src_data)
|
|
|
|
{
|
|
|
|
ERROR_LOG(VIDEO, "Trying to use an invalid texture address 0x%8x", address);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we are recording a FifoLog, keep track of what memory we read.
|
|
|
|
// FifiRecorder does it's own memory modification tracking independant of the texture hashing
|
|
|
|
// below.
|
|
|
|
if (g_bRecordFifoData && !from_tmem)
|
|
|
|
FifoRecorder::GetInstance().UseMemory(address, texture_size + additional_mips_size,
|
|
|
|
MemoryUpdate::TEXTURE_MAP);
|
|
|
|
|
|
|
|
// TODO: This doesn't hash GB tiles for preloaded RGBA8 textures (instead, it's hashing more data
|
|
|
|
// from the low tmem bank than it should)
|
2017-05-29 22:02:09 +00:00
|
|
|
base_hash = GetHash64(src_data, texture_size, textureCacheSafetyColorSampleSize);
|
2016-06-24 08:43:46 +00:00
|
|
|
u32 palette_size = 0;
|
|
|
|
if (isPaletteTexture)
|
|
|
|
{
|
|
|
|
palette_size = TexDecoder_GetPaletteSize(texformat);
|
|
|
|
full_hash = base_hash ^ GetHash64(&texMem[tlutaddr], palette_size,
|
2017-05-29 22:02:09 +00:00
|
|
|
textureCacheSafetyColorSampleSize);
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
full_hash = base_hash;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Search the texture cache for textures by address
|
|
|
|
//
|
|
|
|
// Find all texture cache entries for the current texture address, and decide whether to use one
|
|
|
|
// of
|
|
|
|
// them, or to create a new one
|
|
|
|
//
|
|
|
|
// In most cases, the fastest way is to use only one texture cache entry for the same address.
|
|
|
|
// Usually,
|
|
|
|
// when a texture changes, the old version of the texture is unlikely to be used again. If there
|
|
|
|
// were
|
|
|
|
// new cache entries created for normal texture updates, there would be a slowdown due to a huge
|
|
|
|
// amount
|
|
|
|
// of unused cache entries. Also thanks to texture pooling, overwriting an existing cache entry is
|
|
|
|
// faster than creating a new one from scratch.
|
|
|
|
//
|
|
|
|
// Some games use the same address for different textures though. If the same cache entry was used
|
|
|
|
// in
|
|
|
|
// this case, it would be constantly overwritten, and effectively there wouldn't be any caching
|
|
|
|
// for
|
|
|
|
// those textures. Examples for this are Metroid Prime and Castlevania 3. Metroid Prime has
|
|
|
|
// multiple
|
|
|
|
// sets of fonts on each other stored in a single texture and uses the palette to make different
|
|
|
|
// characters visible or invisible. In Castlevania 3 some textures are used for 2 different things
|
|
|
|
// or
|
|
|
|
// at least in 2 different ways(size 1024x1024 vs 1024x256).
|
|
|
|
//
|
|
|
|
// To determine whether to use multiple cache entries or a single entry, use the following
|
|
|
|
// heuristic:
|
|
|
|
// If the same texture address is used several times during the same frame, assume the address is
|
|
|
|
// used
|
|
|
|
// for different purposes and allow creating an additional cache entry. If there's at least one
|
|
|
|
// entry
|
|
|
|
// that hasn't been used for the same frame, then overwrite it, in order to keep the cache as
|
|
|
|
// small as
|
|
|
|
// possible. If the current texture is found in the cache, use that entry.
|
|
|
|
//
|
|
|
|
// For efb copies, the entry created in CopyRenderTargetToTexture always has to be used, or else
|
|
|
|
// it was
|
|
|
|
// done in vain.
|
2016-12-25 17:48:19 +00:00
|
|
|
auto iter_range = textures_by_address.equal_range(address);
|
|
|
|
TexAddrCache::iterator iter = iter_range.first;
|
|
|
|
TexAddrCache::iterator oldest_entry = iter;
|
2016-06-24 08:43:46 +00:00
|
|
|
int temp_frameCount = 0x7fffffff;
|
2016-12-25 17:48:19 +00:00
|
|
|
TexAddrCache::iterator unconverted_copy = textures_by_address.end();
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
while (iter != iter_range.second)
|
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
TCacheEntry* entry = iter->second;
|
2017-06-29 21:09:32 +00:00
|
|
|
|
|
|
|
// Skip entries that are only left in our texture cache for the tmem cache emulation
|
|
|
|
if (entry->tmem_only)
|
|
|
|
{
|
|
|
|
++iter;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2017-06-28 14:25:01 +00:00
|
|
|
// Do not load strided EFB copies, they are not meant to be used directly.
|
|
|
|
// Also do not directly load EFB copies, which were partly overwritten.
|
2017-07-03 02:24:20 +00:00
|
|
|
if (entry->IsCopy() && entry->native_width == nativeW && static_cast<unsigned int>(entry->native_height * entry->y_scale) == nativeH &&
|
2017-06-28 14:25:01 +00:00
|
|
|
entry->memory_stride == entry->BytesPerRow() && !entry->may_have_overlapping_textures)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
|
|
|
// EFB copies have slightly different rules as EFB copy formats have different
|
|
|
|
// meanings from texture formats.
|
|
|
|
if ((base_hash == entry->hash &&
|
|
|
|
(!isPaletteTexture || g_Config.backend_info.bSupportsPaletteConversion)) ||
|
|
|
|
IsPlayingBackFifologWithBrokenEFBCopies)
|
|
|
|
{
|
|
|
|
// TODO: We should check format/width/height/levels for EFB copies. Checking
|
|
|
|
// format is complicated because EFB copy formats don't exactly match
|
|
|
|
// texture formats. I'm not sure what effect checking width/height/levels
|
|
|
|
// would have.
|
|
|
|
if (!isPaletteTexture || !g_Config.backend_info.bSupportsPaletteConversion)
|
2017-05-29 22:02:09 +00:00
|
|
|
return entry;
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
// Note that we found an unconverted EFB copy, then continue. We'll
|
|
|
|
// perform the conversion later. Currently, we only convert EFB copies to
|
|
|
|
// palette textures; we could do other conversions if it proved to be
|
|
|
|
// beneficial.
|
|
|
|
unconverted_copy = iter;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Aggressively prune EFB copies: if it isn't useful here, it will probably
|
|
|
|
// never be useful again. It's theoretically possible for a game to do
|
|
|
|
// something weird where the copy could become useful in the future, but in
|
|
|
|
// practice it doesn't happen.
|
|
|
|
iter = InvalidateTexture(iter);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// For normal textures, all texture parameters need to match
|
2017-06-26 17:06:50 +00:00
|
|
|
if (!entry->IsCopy() && entry->hash == full_hash && entry->format == full_format &&
|
2016-06-24 08:43:46 +00:00
|
|
|
entry->native_levels >= tex_levels && entry->native_width == nativeW &&
|
|
|
|
entry->native_height == nativeH)
|
|
|
|
{
|
2016-12-25 17:48:19 +00:00
|
|
|
entry = DoPartialTextureUpdates(iter->second, &texMem[tlutaddr], tlutfmt);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
return entry;
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find the texture which hasn't been used for the longest time. Count paletted
|
|
|
|
// textures as the same texture here, when the texture itself is the same. This
|
|
|
|
// improves the performance a lot in some games that use paletted textures.
|
|
|
|
// Example: Sonic the Fighters (inside Sonic Gems Collection)
|
|
|
|
// Skip EFB copies here, so they can be used for partial texture updates
|
|
|
|
if (entry->frameCount != FRAMECOUNT_INVALID && entry->frameCount < temp_frameCount &&
|
2017-06-26 17:06:50 +00:00
|
|
|
!entry->IsCopy() && !(isPaletteTexture && entry->base_hash == base_hash))
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
|
|
|
temp_frameCount = entry->frameCount;
|
|
|
|
oldest_entry = iter;
|
|
|
|
}
|
|
|
|
++iter;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (unconverted_copy != textures_by_address.end())
|
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
TCacheEntry* decoded_entry =
|
2016-09-06 22:57:58 +00:00
|
|
|
ApplyPaletteToEntry(unconverted_copy->second, &texMem[tlutaddr], tlutfmt);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
if (decoded_entry)
|
|
|
|
{
|
2017-05-29 22:02:09 +00:00
|
|
|
return decoded_entry;
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Search the texture cache for normal textures by hash
|
|
|
|
//
|
|
|
|
// If the texture was fully hashed, the address does not need to match. Identical duplicate
|
|
|
|
// textures cause unnecessary slowdowns
|
|
|
|
// Example: Tales of Symphonia (GC) uses over 500 small textures in menus, but only around 70
|
|
|
|
// different ones
|
2017-05-29 22:02:09 +00:00
|
|
|
if (textureCacheSafetyColorSampleSize == 0 ||
|
2016-06-24 08:43:46 +00:00
|
|
|
std::max(texture_size, palette_size) <=
|
2017-05-29 22:02:09 +00:00
|
|
|
(u32)textureCacheSafetyColorSampleSize * 8)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2016-12-25 17:48:19 +00:00
|
|
|
auto hash_range = textures_by_hash.equal_range(full_hash);
|
|
|
|
TexHashCache::iterator hash_iter = hash_range.first;
|
|
|
|
while (hash_iter != hash_range.second)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
TCacheEntry* entry = hash_iter->second;
|
2016-06-24 08:43:46 +00:00
|
|
|
// All parameters, except the address, need to match here
|
|
|
|
if (entry->format == full_format && entry->native_levels >= tex_levels &&
|
2017-07-03 02:24:20 +00:00
|
|
|
entry->native_width == nativeW &&
|
|
|
|
static_cast<unsigned int>(entry->native_height * entry->y_scale) == nativeH)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2016-12-25 17:48:19 +00:00
|
|
|
entry = DoPartialTextureUpdates(hash_iter->second, &texMem[tlutaddr], tlutfmt);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
return entry;
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
2016-12-25 17:48:19 +00:00
|
|
|
++hash_iter;
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If at least one entry was not used for the same frame, overwrite the oldest one
|
|
|
|
if (temp_frameCount != 0x7fffffff)
|
|
|
|
{
|
|
|
|
// pool this texture and make a new one later
|
|
|
|
InvalidateTexture(oldest_entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::shared_ptr<HiresTexture> hires_tex;
|
|
|
|
if (g_ActiveConfig.bHiresTextures)
|
|
|
|
{
|
|
|
|
hires_tex = HiresTexture::Search(src_data, texture_size, &texMem[tlutaddr], palette_size, width,
|
|
|
|
height, texformat, use_mipmaps);
|
|
|
|
|
|
|
|
if (hires_tex)
|
|
|
|
{
|
|
|
|
const auto& level = hires_tex->m_levels[0];
|
|
|
|
if (level.width != width || level.height != height)
|
|
|
|
{
|
|
|
|
width = level.width;
|
|
|
|
height = level.height;
|
|
|
|
}
|
|
|
|
expandedWidth = level.width;
|
|
|
|
expandedHeight = level.height;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// how many levels the allocated texture shall have
|
|
|
|
const u32 texLevels = hires_tex ? (u32)hires_tex->m_levels.size() : tex_levels;
|
|
|
|
|
2016-11-27 08:14:59 +00:00
|
|
|
// We can decode on the GPU if it is a supported format and the flag is enabled.
|
|
|
|
// Currently we don't decode RGBA8 textures from Tmem, as that would require copying from both
|
|
|
|
// banks, and if we're doing an copy we may as well just do the whole thing on the CPU, since
|
|
|
|
// there's no conversion between formats. In the future this could be extended with a separate
|
|
|
|
// shader, however.
|
2017-07-30 19:45:55 +00:00
|
|
|
bool decode_on_gpu = !hires_tex && g_ActiveConfig.UseGPUTextureDecoding() &&
|
|
|
|
g_texture_cache->SupportsGPUTextureDecode(texformat, tlutfmt) &&
|
|
|
|
!(from_tmem && texformat == TextureFormat::RGBA8);
|
2016-11-27 08:14:59 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
// create the entry/texture
|
2017-04-23 04:44:34 +00:00
|
|
|
TextureConfig config;
|
2016-06-24 08:43:46 +00:00
|
|
|
config.width = width;
|
|
|
|
config.height = height;
|
|
|
|
config.levels = texLevels;
|
2017-06-12 17:37:28 +00:00
|
|
|
config.format = hires_tex ? hires_tex->GetFormat() : AbstractTextureFormat::RGBA8;
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2017-10-18 09:02:56 +00:00
|
|
|
ArbitraryMipmapDetector arbitrary_mip_detector;
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
TCacheEntry* entry = AllocateCacheEntry(config);
|
2016-06-24 08:43:46 +00:00
|
|
|
GFX_DEBUGGER_PAUSE_AT(NEXT_NEW_TEXTURE, true);
|
|
|
|
|
|
|
|
if (!entry)
|
|
|
|
return nullptr;
|
|
|
|
|
2017-04-04 21:27:55 +00:00
|
|
|
const u8* tlut = &texMem[tlutaddr];
|
|
|
|
if (hires_tex)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2017-04-16 09:45:22 +00:00
|
|
|
const auto& level = hires_tex->m_levels[0];
|
2017-04-23 04:44:34 +00:00
|
|
|
entry->texture->Load(0, level.width, level.height, level.row_length, level.data.get(),
|
|
|
|
level.data_size);
|
2017-04-04 21:27:55 +00:00
|
|
|
}
|
2017-04-23 04:44:34 +00:00
|
|
|
|
2017-10-18 09:02:56 +00:00
|
|
|
// Initialized to null because only software loading uses this buffer
|
|
|
|
u8* dst_buffer = nullptr;
|
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
if (!hires_tex)
|
2017-04-04 21:27:55 +00:00
|
|
|
{
|
2017-05-29 22:02:09 +00:00
|
|
|
if (decode_on_gpu)
|
2017-10-18 09:02:56 +00:00
|
|
|
{
|
2017-05-29 22:02:09 +00:00
|
|
|
u32 row_stride = bytes_per_block * (expandedWidth / bsw);
|
|
|
|
g_texture_cache->DecodeTextureOnGPU(
|
|
|
|
entry, 0, src_data, texture_size, texformat, width, height,
|
|
|
|
expandedWidth, expandedHeight, row_stride, tlut, tlutfmt);
|
2017-10-18 09:02:56 +00:00
|
|
|
}
|
2017-05-29 22:02:09 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
size_t decoded_texture_size = expandedWidth * sizeof(u32) * expandedHeight;
|
2017-10-18 09:02:56 +00:00
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
// Allocate memory for all levels at once
|
|
|
|
size_t total_texture_size = decoded_texture_size;
|
2017-10-18 09:02:56 +00:00
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
// For the downsample, we need 2 buffers; 1 is 1/4 of the original texture, the other 1/16
|
|
|
|
size_t mip_downsample_buffer_size = decoded_texture_size * 5 / 16;
|
2017-10-18 09:02:56 +00:00
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
size_t prev_level_size = decoded_texture_size;
|
|
|
|
for (u32 i = 1; i < tex_levels; ++i)
|
|
|
|
{
|
|
|
|
prev_level_size /= 4;
|
|
|
|
total_texture_size += prev_level_size;
|
|
|
|
}
|
2017-04-04 21:27:55 +00:00
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
// Add space for the downsampling at the end
|
|
|
|
total_texture_size += mip_downsample_buffer_size;
|
|
|
|
|
|
|
|
CheckTempSize(total_texture_size);
|
|
|
|
dst_buffer = temp;
|
|
|
|
if (!(texformat == TextureFormat::RGBA8 && from_tmem))
|
|
|
|
{
|
|
|
|
TexDecoder_Decode(dst_buffer, src_data, expandedWidth, expandedHeight, texformat, tlut,
|
|
|
|
tlutfmt);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
u8* src_data_gb =
|
|
|
|
&texMem[tmem_address_odd];
|
|
|
|
TexDecoder_DecodeRGBA8FromTmem(dst_buffer, src_data, src_data_gb, expandedWidth, expandedHeight);
|
|
|
|
}
|
2017-10-18 09:02:56 +00:00
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
entry->texture->Load(0, width, height, expandedWidth, dst_buffer, decoded_texture_size);
|
2017-10-18 09:02:56 +00:00
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
arbitrary_mip_detector.AddLevel(width, height, expandedWidth, dst_buffer);
|
|
|
|
|
|
|
|
dst_buffer += decoded_texture_size;
|
|
|
|
}
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
|
2016-12-25 17:48:19 +00:00
|
|
|
iter = textures_by_address.emplace(address, entry);
|
2017-05-29 22:02:09 +00:00
|
|
|
if (textureCacheSafetyColorSampleSize == 0 ||
|
2016-06-24 08:43:46 +00:00
|
|
|
std::max(texture_size, palette_size) <=
|
2017-05-29 22:02:09 +00:00
|
|
|
(u32)textureCacheSafetyColorSampleSize * 8)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
|
|
|
entry->textures_by_hash_iter = textures_by_hash.emplace(full_hash, entry);
|
|
|
|
}
|
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
entry->SetGeneralParameters(address, texture_size, full_format, false);
|
2016-06-24 08:43:46 +00:00
|
|
|
entry->SetDimensions(nativeW, nativeH, tex_levels);
|
|
|
|
entry->SetHashes(base_hash, full_hash);
|
|
|
|
entry->is_custom_tex = hires_tex != nullptr;
|
2017-06-28 20:33:19 +00:00
|
|
|
entry->memory_stride = entry->BytesPerRow();
|
2017-06-26 17:06:50 +00:00
|
|
|
entry->SetNotCopy();
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
std::string basename = "";
|
|
|
|
if (g_ActiveConfig.bDumpTextures && !hires_tex)
|
|
|
|
{
|
|
|
|
basename = HiresTexture::GenBaseName(src_data, texture_size, &texMem[tlutaddr], palette_size,
|
|
|
|
width, height, texformat, use_mipmaps, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hires_tex)
|
|
|
|
{
|
|
|
|
for (u32 level_index = 1; level_index != texLevels; ++level_index)
|
|
|
|
{
|
|
|
|
const auto& level = hires_tex->m_levels[level_index];
|
2017-04-23 04:44:34 +00:00
|
|
|
entry->texture->Load(level_index, level.width, level.height, level.row_length,
|
|
|
|
level.data.get(), level.data_size);
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// load mips - TODO: Loading mipmaps from tmem is untested!
|
|
|
|
src_data += texture_size;
|
|
|
|
|
|
|
|
const u8* ptr_even = nullptr;
|
|
|
|
const u8* ptr_odd = nullptr;
|
|
|
|
if (from_tmem)
|
|
|
|
{
|
2017-05-29 22:02:09 +00:00
|
|
|
ptr_even = &texMem[tmem_address_even + texture_size];
|
|
|
|
ptr_odd = &texMem[tmem_address_odd];
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (u32 level = 1; level != texLevels; ++level)
|
|
|
|
{
|
|
|
|
const u32 mip_width = CalculateLevelSize(width, level);
|
|
|
|
const u32 mip_height = CalculateLevelSize(height, level);
|
2016-11-27 10:56:22 +00:00
|
|
|
const u32 expanded_mip_width = Common::AlignUp(mip_width, bsw);
|
|
|
|
const u32 expanded_mip_height = Common::AlignUp(mip_height, bsh);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
const u8*& mip_src_data = from_tmem ? ((level % 2) ? ptr_odd : ptr_even) : src_data;
|
2016-11-27 08:14:59 +00:00
|
|
|
size_t mip_size =
|
2016-06-24 08:43:46 +00:00
|
|
|
TexDecoder_GetTextureSizeInBytes(expanded_mip_width, expanded_mip_height, texformat);
|
2016-11-27 08:14:59 +00:00
|
|
|
|
|
|
|
if (decode_on_gpu)
|
|
|
|
{
|
2017-04-07 13:00:42 +00:00
|
|
|
u32 row_stride = bytes_per_block * (expanded_mip_width / bsw);
|
2017-07-30 19:45:55 +00:00
|
|
|
g_texture_cache->DecodeTextureOnGPU(entry, level, mip_src_data, mip_size, texformat,
|
|
|
|
mip_width, mip_height, expanded_mip_width,
|
|
|
|
expanded_mip_height, row_stride, tlut, tlutfmt);
|
2016-11-27 08:14:59 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-10-18 09:02:56 +00:00
|
|
|
// No need to call CheckTempSize here, as the whole buffer is preallocated at the beginning
|
2017-04-16 09:45:22 +00:00
|
|
|
size_t decoded_mip_size = expanded_mip_width * sizeof(u32) * expanded_mip_height;
|
2017-10-18 09:02:56 +00:00
|
|
|
TexDecoder_Decode(dst_buffer, mip_src_data, expanded_mip_width, expanded_mip_height,
|
|
|
|
texformat, tlut, tlutfmt);
|
|
|
|
entry->texture->Load(level, mip_width, mip_height, expanded_mip_width, dst_buffer,
|
2017-04-23 04:44:34 +00:00
|
|
|
decoded_mip_size);
|
2017-10-18 09:02:56 +00:00
|
|
|
|
|
|
|
arbitrary_mip_detector.AddLevel(mip_width, mip_height, expanded_mip_width, dst_buffer);
|
|
|
|
|
|
|
|
dst_buffer += decoded_mip_size;
|
2016-11-27 08:14:59 +00:00
|
|
|
}
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2016-11-27 08:14:59 +00:00
|
|
|
mip_src_data += mip_size;
|
2017-10-18 09:02:56 +00:00
|
|
|
}
|
|
|
|
}
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2017-10-18 09:02:56 +00:00
|
|
|
entry->has_arbitrary_mips = arbitrary_mip_detector.HasArbitraryMipmaps(dst_buffer);
|
|
|
|
|
|
|
|
if (g_ActiveConfig.bDumpTextures)
|
|
|
|
{
|
|
|
|
for (u32 level = 0; level < texLevels; ++level)
|
|
|
|
{
|
|
|
|
DumpTexture(entry, basename, level, entry->has_arbitrary_mips);
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
INCSTAT(stats.numTexturesUploaded);
|
|
|
|
SETSTAT(stats.numTexturesAlive, textures_by_address.size());
|
|
|
|
|
2016-12-25 17:48:19 +00:00
|
|
|
entry = DoPartialTextureUpdates(iter->second, &texMem[tlutaddr], tlutfmt);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
return entry;
|
2010-10-19 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
void TextureCacheBase::CopyRenderTargetToTexture(u32 dstAddr, EFBCopyFormat dstFormat,
|
|
|
|
u32 dstStride, bool is_depth_copy,
|
|
|
|
const EFBRectangle& srcRect, bool isIntensity,
|
2017-08-15 04:07:39 +00:00
|
|
|
bool scaleByHalf, float y_scale, float gamma)
|
2010-10-19 22:24:27 +00:00
|
|
|
{
|
2016-06-24 08:43:46 +00:00
|
|
|
// Emulation methods:
|
|
|
|
//
|
|
|
|
// - EFB to RAM:
|
|
|
|
// Encodes the requested EFB data at its native resolution to the emulated RAM using shaders.
|
|
|
|
// Load() decodes the data from there again (using TextureDecoder) if the EFB copy is being
|
|
|
|
// used as a texture again.
|
|
|
|
// Advantage: CPU can read data from the EFB copy and we don't lose any important updates to
|
|
|
|
// the texture
|
|
|
|
// Disadvantage: Encoding+decoding steps often are redundant because only some games read or
|
|
|
|
// modify EFB copies before using them as textures.
|
|
|
|
//
|
|
|
|
// - EFB to texture:
|
|
|
|
// Copies the requested EFB data to a texture object in VRAM, performing any color conversion
|
|
|
|
// using shaders.
|
|
|
|
// Advantage: Works for many games, since in most cases EFB copies aren't read or modified at
|
|
|
|
// all before being used as a texture again.
|
|
|
|
// Since we don't do any further encoding or decoding here, this method is much
|
|
|
|
// faster.
|
|
|
|
// It also allows enhancing the visual quality by doing scaled EFB copies.
|
|
|
|
//
|
|
|
|
// - Hybrid EFB copies:
|
|
|
|
// 1a) Whenever this function gets called, encode the requested EFB data to RAM (like EFB to
|
|
|
|
// RAM)
|
|
|
|
// 1b) Set type to TCET_EC_DYNAMIC for all texture cache entries in the destination address
|
|
|
|
// range.
|
|
|
|
// If EFB copy caching is enabled, further checks will (try to) prevent redundant EFB
|
|
|
|
// copies.
|
|
|
|
// 2) Check if a texture cache entry for the specified dstAddr already exists (i.e. if an EFB
|
|
|
|
// copy was triggered to that address before):
|
|
|
|
// 2a) Entry doesn't exist:
|
|
|
|
// - Also copy the requested EFB data to a texture object in VRAM (like EFB to texture)
|
|
|
|
// - Create a texture cache entry for the target (type = TCET_EC_VRAM)
|
|
|
|
// - Store a hash of the encoded RAM data in the texcache entry.
|
|
|
|
// 2b) Entry exists AND type is TCET_EC_VRAM:
|
|
|
|
// - Like case 2a, but reuse the old texcache entry instead of creating a new one.
|
|
|
|
// 2c) Entry exists AND type is TCET_EC_DYNAMIC:
|
|
|
|
// - Only encode the texture to RAM (like EFB to RAM) and store a hash of the encoded
|
|
|
|
// data in the existing texcache entry.
|
|
|
|
// - Do NOT copy the requested EFB data to a VRAM object. Reason: the texture is dynamic,
|
|
|
|
// i.e. the CPU is modifying it. Storing a VRAM copy is useless, because we'd always end
|
|
|
|
// up deleting it and reloading the data from RAM anyway.
|
|
|
|
// 3) If the EFB copy gets used as a texture, compare the source RAM hash with the hash you
|
|
|
|
// stored when encoding the EFB data to RAM.
|
|
|
|
// 3a) If the two hashes match AND type is TCET_EC_VRAM, reuse the VRAM copy you created
|
|
|
|
// 3b) If the two hashes differ AND type is TCET_EC_VRAM, screw your existing VRAM copy. Set
|
|
|
|
// type to TCET_EC_DYNAMIC.
|
|
|
|
// Redecode the source RAM data to a VRAM object. The entry basically behaves like a
|
|
|
|
// normal texture now.
|
|
|
|
// 3c) If type is TCET_EC_DYNAMIC, treat the EFB copy like a normal texture.
|
|
|
|
// Advantage: Non-dynamic EFB copies can be visually enhanced like with EFB to texture.
|
|
|
|
// Compatibility is as good as EFB to RAM.
|
|
|
|
// Disadvantage: Slower than EFB to texture and often even slower than EFB to RAM.
|
|
|
|
// EFB copy cache depends on accurate texture hashing being enabled. However,
|
|
|
|
// with accurate hashing you end up being as slow as without a copy cache
|
|
|
|
// anyway.
|
|
|
|
//
|
|
|
|
// Disadvantage of all methods: Calling this function requires the GPU to perform a pipeline flush
|
|
|
|
// which stalls any further CPU processing.
|
|
|
|
//
|
|
|
|
// For historical reasons, Dolphin doesn't actually implement "pure" EFB to RAM emulation, but
|
|
|
|
// only EFB to texture and hybrid EFB copies.
|
|
|
|
|
|
|
|
float colmat[28] = {0};
|
|
|
|
float* const fConstAdd = colmat + 16;
|
|
|
|
float* const ColorMask = colmat + 20;
|
|
|
|
ColorMask[0] = ColorMask[1] = ColorMask[2] = ColorMask[3] = 255.0f;
|
|
|
|
ColorMask[4] = ColorMask[5] = ColorMask[6] = ColorMask[7] = 1.0f / 255.0f;
|
2017-06-07 11:16:02 +00:00
|
|
|
unsigned int cbufid = UINT_MAX;
|
2017-07-30 19:45:55 +00:00
|
|
|
PEControl::PixelFormat srcFormat = bpmem.zcontrol.pixel_format;
|
2017-04-04 13:55:36 +00:00
|
|
|
bool efbHasAlpha = srcFormat == PEControl::RGBA6_Z24;
|
2017-05-29 22:02:09 +00:00
|
|
|
|
|
|
|
bool copy_to_ram = !g_ActiveConfig.bSkipEFBCopyToRam;
|
|
|
|
bool copy_to_vram = g_ActiveConfig.backend_info.bSupportsCopyToVram;
|
|
|
|
bool is_xfb_copy = false;
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2016-12-26 19:54:37 +00:00
|
|
|
if (is_depth_copy)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
|
|
|
switch (dstFormat)
|
|
|
|
{
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::R4: // Z4
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[3] = colmat[7] = colmat[11] = colmat[15] = 1.0f;
|
|
|
|
cbufid = 0;
|
|
|
|
break;
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::R8_0x1: // Z8
|
|
|
|
case EFBCopyFormat::R8: // Z8H
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[0] = colmat[4] = colmat[8] = colmat[12] = 1.0f;
|
|
|
|
cbufid = 1;
|
|
|
|
break;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::RA8: // Z16
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[1] = colmat[5] = colmat[9] = colmat[12] = 1.0f;
|
|
|
|
cbufid = 2;
|
|
|
|
break;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::RG8: // Z16 (reverse order)
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[0] = colmat[4] = colmat[8] = colmat[13] = 1.0f;
|
|
|
|
cbufid = 3;
|
|
|
|
break;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::RGBA8: // Z24X8
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[0] = colmat[5] = colmat[10] = 1.0f;
|
|
|
|
cbufid = 4;
|
|
|
|
break;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::G8: // Z8M
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[1] = colmat[5] = colmat[9] = colmat[13] = 1.0f;
|
|
|
|
cbufid = 5;
|
|
|
|
break;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::B8: // Z8L
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[2] = colmat[6] = colmat[10] = colmat[14] = 1.0f;
|
|
|
|
cbufid = 6;
|
|
|
|
break;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::GB8: // Z16L - copy lower 16 depth bits
|
2016-06-24 08:43:46 +00:00
|
|
|
// expected to be used as an IA8 texture (upper 8 bits stored as intensity, lower 8 bits
|
|
|
|
// stored as alpha)
|
|
|
|
// Used e.g. in Zelda: Skyward Sword
|
|
|
|
colmat[1] = colmat[5] = colmat[9] = colmat[14] = 1.0f;
|
|
|
|
cbufid = 7;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2017-07-30 19:45:55 +00:00
|
|
|
ERROR_LOG(VIDEO, "Unknown copy zbuf format: 0x%X", static_cast<int>(dstFormat));
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[2] = colmat[5] = colmat[8] = 1.0f;
|
|
|
|
cbufid = 8;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (isIntensity)
|
|
|
|
{
|
|
|
|
fConstAdd[0] = fConstAdd[1] = fConstAdd[2] = 16.0f / 255.0f;
|
|
|
|
switch (dstFormat)
|
|
|
|
{
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::R4: // I4
|
|
|
|
case EFBCopyFormat::R8_0x1: // I8
|
2017-08-09 07:02:27 +00:00
|
|
|
case EFBCopyFormat::R8: // I8
|
|
|
|
case EFBCopyFormat::RA4: // IA4
|
|
|
|
case EFBCopyFormat::RA8: // IA8
|
2016-06-24 08:43:46 +00:00
|
|
|
// TODO - verify these coefficients
|
|
|
|
colmat[0] = 0.257f;
|
|
|
|
colmat[1] = 0.504f;
|
|
|
|
colmat[2] = 0.098f;
|
|
|
|
colmat[4] = 0.257f;
|
|
|
|
colmat[5] = 0.504f;
|
|
|
|
colmat[6] = 0.098f;
|
|
|
|
colmat[8] = 0.257f;
|
|
|
|
colmat[9] = 0.504f;
|
|
|
|
colmat[10] = 0.098f;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
if (dstFormat == EFBCopyFormat::R4 || dstFormat == EFBCopyFormat::R8_0x1 ||
|
|
|
|
dstFormat == EFBCopyFormat::R8)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
|
|
|
colmat[12] = 0.257f;
|
|
|
|
colmat[13] = 0.504f;
|
|
|
|
colmat[14] = 0.098f;
|
|
|
|
fConstAdd[3] = 16.0f / 255.0f;
|
2017-07-30 19:45:55 +00:00
|
|
|
if (dstFormat == EFBCopyFormat::R4)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2016-12-14 13:58:23 +00:00
|
|
|
ColorMask[0] = ColorMask[1] = ColorMask[2] = 255.0f / 16.0f;
|
2016-06-24 08:43:46 +00:00
|
|
|
ColorMask[4] = ColorMask[5] = ColorMask[6] = 1.0f / 15.0f;
|
|
|
|
cbufid = 9;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
cbufid = 10;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else // alpha
|
|
|
|
{
|
|
|
|
colmat[15] = 1;
|
2017-07-30 19:45:55 +00:00
|
|
|
if (dstFormat == EFBCopyFormat::RA4)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2016-12-14 13:58:23 +00:00
|
|
|
ColorMask[0] = ColorMask[1] = ColorMask[2] = ColorMask[3] = 255.0f / 16.0f;
|
2016-06-24 08:43:46 +00:00
|
|
|
ColorMask[4] = ColorMask[5] = ColorMask[6] = ColorMask[7] = 1.0f / 15.0f;
|
|
|
|
cbufid = 11;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
cbufid = 12;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2017-07-30 19:45:55 +00:00
|
|
|
ERROR_LOG(VIDEO, "Unknown copy intensity format: 0x%X", static_cast<int>(dstFormat));
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[0] = colmat[5] = colmat[10] = colmat[15] = 1.0f;
|
|
|
|
cbufid = 13;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
switch (dstFormat)
|
|
|
|
{
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::R4: // R4
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[0] = colmat[4] = colmat[8] = colmat[12] = 1;
|
2016-12-14 13:58:23 +00:00
|
|
|
ColorMask[0] = 255.0f / 16.0f;
|
2016-06-24 08:43:46 +00:00
|
|
|
ColorMask[4] = 1.0f / 15.0f;
|
|
|
|
cbufid = 14;
|
|
|
|
break;
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::R8_0x1: // R8
|
|
|
|
case EFBCopyFormat::R8: // R8
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[0] = colmat[4] = colmat[8] = colmat[12] = 1;
|
|
|
|
cbufid = 15;
|
|
|
|
break;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::RA4: // RA4
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[0] = colmat[4] = colmat[8] = colmat[15] = 1.0f;
|
2016-12-14 13:58:23 +00:00
|
|
|
ColorMask[0] = ColorMask[3] = 255.0f / 16.0f;
|
2016-06-24 08:43:46 +00:00
|
|
|
ColorMask[4] = ColorMask[7] = 1.0f / 15.0f;
|
|
|
|
|
|
|
|
cbufid = 16;
|
|
|
|
if (!efbHasAlpha)
|
|
|
|
{
|
|
|
|
ColorMask[3] = 0.0f;
|
|
|
|
fConstAdd[3] = 1.0f;
|
|
|
|
cbufid = 17;
|
|
|
|
}
|
|
|
|
break;
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::RA8: // RA8
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[0] = colmat[4] = colmat[8] = colmat[15] = 1.0f;
|
|
|
|
|
|
|
|
cbufid = 18;
|
|
|
|
if (!efbHasAlpha)
|
|
|
|
{
|
|
|
|
ColorMask[3] = 0.0f;
|
|
|
|
fConstAdd[3] = 1.0f;
|
|
|
|
cbufid = 19;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::A8: // A8
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[3] = colmat[7] = colmat[11] = colmat[15] = 1.0f;
|
|
|
|
|
|
|
|
cbufid = 20;
|
|
|
|
if (!efbHasAlpha)
|
|
|
|
{
|
|
|
|
ColorMask[3] = 0.0f;
|
|
|
|
fConstAdd[0] = 1.0f;
|
|
|
|
fConstAdd[1] = 1.0f;
|
|
|
|
fConstAdd[2] = 1.0f;
|
|
|
|
fConstAdd[3] = 1.0f;
|
|
|
|
cbufid = 21;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::G8: // G8
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[1] = colmat[5] = colmat[9] = colmat[13] = 1.0f;
|
|
|
|
cbufid = 22;
|
|
|
|
break;
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::B8: // B8
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[2] = colmat[6] = colmat[10] = colmat[14] = 1.0f;
|
|
|
|
cbufid = 23;
|
|
|
|
break;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::RG8: // RG8
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[0] = colmat[4] = colmat[8] = colmat[13] = 1.0f;
|
|
|
|
cbufid = 24;
|
|
|
|
break;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::GB8: // GB8
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[1] = colmat[5] = colmat[9] = colmat[14] = 1.0f;
|
|
|
|
cbufid = 25;
|
|
|
|
break;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::RGB565: // RGB565
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[0] = colmat[5] = colmat[10] = 1.0f;
|
2016-12-14 13:58:23 +00:00
|
|
|
ColorMask[0] = ColorMask[2] = 255.0f / 8.0f;
|
2016-06-24 08:43:46 +00:00
|
|
|
ColorMask[4] = ColorMask[6] = 1.0f / 31.0f;
|
2016-12-14 13:58:23 +00:00
|
|
|
ColorMask[1] = 255.0f / 4.0f;
|
2016-06-24 08:43:46 +00:00
|
|
|
ColorMask[5] = 1.0f / 63.0f;
|
|
|
|
fConstAdd[3] = 1.0f; // set alpha to 1
|
|
|
|
cbufid = 26;
|
|
|
|
break;
|
|
|
|
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::RGB5A3: // RGB5A3
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[0] = colmat[5] = colmat[10] = colmat[15] = 1.0f;
|
2016-12-14 13:58:23 +00:00
|
|
|
ColorMask[0] = ColorMask[1] = ColorMask[2] = 255.0f / 8.0f;
|
2016-06-24 08:43:46 +00:00
|
|
|
ColorMask[4] = ColorMask[5] = ColorMask[6] = 1.0f / 31.0f;
|
2016-12-14 13:58:23 +00:00
|
|
|
ColorMask[3] = 255.0f / 32.0f;
|
2016-06-24 08:43:46 +00:00
|
|
|
ColorMask[7] = 1.0f / 7.0f;
|
|
|
|
|
|
|
|
cbufid = 27;
|
|
|
|
if (!efbHasAlpha)
|
|
|
|
{
|
|
|
|
ColorMask[3] = 0.0f;
|
|
|
|
fConstAdd[3] = 1.0f;
|
|
|
|
cbufid = 28;
|
|
|
|
}
|
|
|
|
break;
|
2017-07-30 19:45:55 +00:00
|
|
|
case EFBCopyFormat::RGBA8: // RGBA8
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[0] = colmat[5] = colmat[10] = colmat[15] = 1.0f;
|
|
|
|
|
|
|
|
cbufid = 29;
|
|
|
|
if (!efbHasAlpha)
|
|
|
|
{
|
|
|
|
ColorMask[3] = 0.0f;
|
|
|
|
fConstAdd[3] = 1.0f;
|
|
|
|
cbufid = 30;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
case EFBCopyFormat::XFB: // XFB copy, we just pretend it's an RGBX copy
|
|
|
|
colmat[0] = colmat[5] = colmat[10] = colmat[15] = 1.0f;
|
|
|
|
ColorMask[3] = 0.0f;
|
|
|
|
fConstAdd[3] = 1.0f;
|
|
|
|
cbufid = 30; // just re-use the RGBX8 cbufid from above
|
2017-06-26 03:23:47 +00:00
|
|
|
copy_to_ram = !g_ActiveConfig.bSkipXFBCopyToRam;
|
2017-05-29 22:02:09 +00:00
|
|
|
is_xfb_copy = true;
|
|
|
|
break;
|
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
default:
|
2017-07-30 19:45:55 +00:00
|
|
|
ERROR_LOG(VIDEO, "Unknown copy color format: 0x%X", static_cast<int>(dstFormat));
|
2016-06-24 08:43:46 +00:00
|
|
|
colmat[0] = colmat[5] = colmat[10] = colmat[15] = 1.0f;
|
|
|
|
cbufid = 31;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
u8* dst = Memory::GetPointer(dstAddr);
|
|
|
|
if (dst == nullptr)
|
|
|
|
{
|
|
|
|
ERROR_LOG(VIDEO, "Trying to copy from EFB to invalid address 0x%8x", dstAddr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const unsigned int tex_w = scaleByHalf ? srcRect.GetWidth() / 2 : srcRect.GetWidth();
|
|
|
|
const unsigned int tex_h = scaleByHalf ? srcRect.GetHeight() / 2 : srcRect.GetHeight();
|
|
|
|
|
2017-03-04 06:39:50 +00:00
|
|
|
unsigned int scaled_tex_w =
|
|
|
|
g_ActiveConfig.bCopyEFBScaled ? g_renderer->EFBToScaledX(tex_w) : tex_w;
|
|
|
|
unsigned int scaled_tex_h =
|
|
|
|
g_ActiveConfig.bCopyEFBScaled ? g_renderer->EFBToScaledY(tex_h) : tex_h;
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
// Get the base (in memory) format of this efb copy.
|
2017-07-30 19:45:55 +00:00
|
|
|
TextureFormat baseFormat = TexDecoder_GetEFBCopyBaseFormat(dstFormat);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
u32 blockH = TexDecoder_GetBlockHeightInTexels(baseFormat);
|
|
|
|
const u32 blockW = TexDecoder_GetBlockWidthInTexels(baseFormat);
|
|
|
|
|
|
|
|
// Round up source height to multiple of block size
|
2017-07-03 02:24:20 +00:00
|
|
|
u32 actualHeight = Common::AlignUp(static_cast<unsigned int>(tex_h * y_scale), blockH);
|
2016-11-27 10:56:22 +00:00
|
|
|
const u32 actualWidth = Common::AlignUp(tex_w, blockW);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
u32 num_blocks_y = actualHeight / blockH;
|
|
|
|
const u32 num_blocks_x = actualWidth / blockW;
|
|
|
|
|
|
|
|
// RGBA takes two cache lines per block; all others take one
|
2017-07-30 19:45:55 +00:00
|
|
|
const u32 bytes_per_block = baseFormat == TextureFormat::RGBA8 ? 64 : 32;
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2016-12-26 17:41:34 +00:00
|
|
|
const u32 bytes_per_row = num_blocks_x * bytes_per_block;
|
|
|
|
const u32 covered_range = num_blocks_y * dstStride;
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
if (copy_to_ram)
|
|
|
|
{
|
2017-07-03 02:24:20 +00:00
|
|
|
EFBCopyParams format(srcFormat, dstFormat, is_depth_copy, isIntensity, y_scale);
|
2017-07-30 19:45:55 +00:00
|
|
|
CopyEFB(dst, format, tex_w, bytes_per_row, num_blocks_y, dstStride, srcRect, scaleByHalf);
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Hack: Most games don't actually need the correct texture data in RAM
|
|
|
|
// and we can just keep a copy in VRAM. We zero the memory so we
|
|
|
|
// can check it hasn't changed before using our copy in VRAM.
|
|
|
|
u8* ptr = dst;
|
|
|
|
for (u32 i = 0; i < num_blocks_y; i++)
|
|
|
|
{
|
|
|
|
memset(ptr, 0, bytes_per_row);
|
|
|
|
ptr += dstStride;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (g_bRecordFifoData)
|
|
|
|
{
|
|
|
|
// Mark the memory behind this efb copy as dynamicly generated for the Fifo log
|
|
|
|
u32 address = dstAddr;
|
|
|
|
for (u32 i = 0; i < num_blocks_y; i++)
|
|
|
|
{
|
|
|
|
FifoRecorder::GetInstance().UseMemory(address, bytes_per_row, MemoryUpdate::TEXTURE_MAP,
|
|
|
|
true);
|
|
|
|
address += dstStride;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dstStride < bytes_per_row)
|
|
|
|
{
|
|
|
|
// This kind of efb copy results in a scrambled image.
|
|
|
|
// I'm pretty sure no game actually wants to do this, it might be caused by a
|
|
|
|
// programming bug in the game, or a CPU/Bounding box emulation issue with dolphin.
|
|
|
|
// The copy_to_ram code path above handles this "correctly" and scrambles the image
|
|
|
|
// but the copy_to_vram code path just saves and uses unscrambled texture instead.
|
|
|
|
|
|
|
|
// To avoid a "incorrect" result, we simply skip doing the copy_to_vram code path
|
|
|
|
// so if the game does try to use the scrambled texture, dolphin will grab the scrambled
|
|
|
|
// texture (or black if copy_to_ram is also disabled) out of ram.
|
|
|
|
ERROR_LOG(VIDEO, "Memory stride too small (%i < %i)", dstStride, bytes_per_row);
|
|
|
|
copy_to_vram = false;
|
|
|
|
}
|
|
|
|
|
2017-06-28 14:25:01 +00:00
|
|
|
// Invalidate all textures, if they are either fully overwritten by our efb copy, or if they
|
|
|
|
// have a different stride than our efb copy. Partly overwritten textures with the same stride
|
|
|
|
// as our efb copy are marked to check them for partial texture updates.
|
|
|
|
// TODO: The logic to detect overlapping strided efb copies is not 100% accurate.
|
|
|
|
bool strided_efb_copy = dstStride != bytes_per_row;
|
2016-12-26 17:41:34 +00:00
|
|
|
auto iter = FindOverlappingTextures(dstAddr, covered_range);
|
|
|
|
while (iter.first != iter.second)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
TCacheEntry* entry = iter.first->second;
|
2016-12-26 17:41:34 +00:00
|
|
|
if (entry->OverlapsMemoryRange(dstAddr, covered_range))
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2017-06-28 14:25:01 +00:00
|
|
|
u32 overlap_range = std::min(entry->addr + entry->size_in_bytes, dstAddr + covered_range) -
|
|
|
|
std::max(entry->addr, dstAddr);
|
|
|
|
if (!copy_to_vram || entry->memory_stride != dstStride ||
|
|
|
|
(!strided_efb_copy && entry->size_in_bytes == overlap_range) ||
|
|
|
|
(strided_efb_copy && entry->size_in_bytes == overlap_range && entry->addr == dstAddr))
|
2016-12-26 17:41:34 +00:00
|
|
|
{
|
|
|
|
iter.first = InvalidateTexture(iter.first);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
entry->may_have_overlapping_textures = true;
|
2017-07-12 20:49:06 +00:00
|
|
|
|
|
|
|
// 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 (entry->textures_by_hash_iter != textures_by_hash.end())
|
|
|
|
{
|
|
|
|
textures_by_hash.erase(entry->textures_by_hash_iter);
|
|
|
|
entry->textures_by_hash_iter = textures_by_hash.end();
|
|
|
|
}
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
2016-12-26 17:41:34 +00:00
|
|
|
++iter.first;
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (copy_to_vram)
|
|
|
|
{
|
|
|
|
// create the texture
|
2017-04-23 04:44:34 +00:00
|
|
|
TextureConfig config;
|
2016-06-24 08:43:46 +00:00
|
|
|
config.rendertarget = true;
|
|
|
|
config.width = scaled_tex_w;
|
|
|
|
config.height = scaled_tex_h;
|
|
|
|
config.layers = FramebufferManagerBase::GetEFBLayers();
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
TCacheEntry* entry = AllocateCacheEntry(config);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
if (entry)
|
|
|
|
{
|
2017-05-29 22:02:09 +00:00
|
|
|
entry->SetGeneralParameters(dstAddr, 0, baseFormat, is_xfb_copy);
|
2016-06-24 08:43:46 +00:00
|
|
|
entry->SetDimensions(tex_w, tex_h, 1);
|
2017-07-03 02:24:20 +00:00
|
|
|
entry->y_scale = y_scale;
|
2017-08-15 04:07:39 +00:00
|
|
|
entry->gamma = gamma;
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
entry->frameCount = FRAMECOUNT_INVALID;
|
2017-06-26 17:06:50 +00:00
|
|
|
if (is_xfb_copy)
|
|
|
|
{
|
|
|
|
entry->should_force_safe_hashing = is_xfb_copy;
|
|
|
|
entry->SetXfbCopy(dstStride);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
entry->SetEfbCopy(dstStride);
|
|
|
|
}
|
2017-06-28 14:25:01 +00:00
|
|
|
entry->may_have_overlapping_textures = false;
|
2016-06-24 08:43:46 +00:00
|
|
|
entry->is_custom_tex = false;
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
CopyEFBToCacheEntry(entry, is_depth_copy, srcRect, scaleByHalf, cbufid, colmat);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
|
|
|
u64 hash = entry->CalculateHash();
|
|
|
|
entry->SetHashes(hash, hash);
|
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
if (g_ActiveConfig.bDumpEFBTarget && !is_xfb_copy)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
2017-06-03 01:33:26 +00:00
|
|
|
static int efb_count = 0;
|
2017-04-23 04:44:34 +00:00
|
|
|
entry->texture->Save(StringFromFormat("%sefb_frame_%i.png",
|
|
|
|
File::GetUserPath(D_DUMPTEXTURES_IDX).c_str(),
|
2017-06-03 01:33:26 +00:00
|
|
|
efb_count++),
|
|
|
|
0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (g_ActiveConfig.bDumpXFBTarget && is_xfb_copy)
|
|
|
|
{
|
|
|
|
static int xfb_count = 0;
|
|
|
|
entry->texture->Save(StringFromFormat("%sxfb_frame_%i.png",
|
|
|
|
File::GetUserPath(D_DUMPTEXTURES_IDX).c_str(),
|
|
|
|
xfb_count++),
|
2017-04-23 04:44:34 +00:00
|
|
|
0);
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
|
2016-12-25 17:48:19 +00:00
|
|
|
textures_by_address.emplace(dstAddr, entry);
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
}
|
2010-12-27 22:17:19 +00:00
|
|
|
}
|
2014-06-11 23:04:42 +00:00
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
TextureCacheBase::TCacheEntry* TextureCacheBase::AllocateCacheEntry(const TextureConfig& config)
|
|
|
|
{
|
|
|
|
std::unique_ptr<AbstractTexture> texture = AllocateTexture(config);
|
|
|
|
|
|
|
|
if (!texture)
|
|
|
|
{
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
TCacheEntry* cacheEntry = new TCacheEntry(std::move(texture));
|
|
|
|
cacheEntry->textures_by_hash_iter = textures_by_hash.end();
|
2017-08-20 19:24:37 +00:00
|
|
|
cacheEntry->id = last_entry_id++;
|
2017-04-23 04:44:34 +00:00
|
|
|
return cacheEntry;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<AbstractTexture> TextureCacheBase::AllocateTexture(const TextureConfig& config)
|
2014-06-11 23:04:42 +00:00
|
|
|
{
|
2016-10-05 14:27:02 +00:00
|
|
|
TexPool::iterator iter = FindMatchingTextureFromPool(config);
|
2017-04-23 04:44:34 +00:00
|
|
|
std::unique_ptr<AbstractTexture> entry;
|
2016-06-24 08:43:46 +00:00
|
|
|
if (iter != texture_pool.end())
|
|
|
|
{
|
2017-04-23 04:44:34 +00:00
|
|
|
entry = std::move(iter->second.texture);
|
2016-06-24 08:43:46 +00:00
|
|
|
texture_pool.erase(iter);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-09-06 22:57:58 +00:00
|
|
|
entry = CreateTexture(config);
|
2016-06-24 08:43:46 +00:00
|
|
|
if (!entry)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
INCSTAT(stats.numTexturesCreated);
|
|
|
|
}
|
|
|
|
|
|
|
|
return entry;
|
2015-02-22 17:42:19 +00:00
|
|
|
}
|
|
|
|
|
2016-10-05 14:27:02 +00:00
|
|
|
TextureCacheBase::TexPool::iterator
|
2017-04-23 04:44:34 +00:00
|
|
|
TextureCacheBase::FindMatchingTextureFromPool(const TextureConfig& config)
|
2016-10-05 14:27:02 +00:00
|
|
|
{
|
|
|
|
// Find a texture from the pool that does not have a frameCount of FRAMECOUNT_INVALID.
|
|
|
|
// This prevents a texture from being used twice in a single frame with different data,
|
|
|
|
// which potentially means that a driver has to maintain two copies of the texture anyway.
|
2017-03-22 08:15:09 +00:00
|
|
|
// 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.
|
2016-10-05 14:27:02 +00:00
|
|
|
auto range = texture_pool.equal_range(config);
|
|
|
|
auto matching_iter = std::find_if(range.first, range.second, [](const auto& iter) {
|
2017-04-23 04:44:34 +00:00
|
|
|
return iter.first.rendertarget || iter.second.frameCount != FRAMECOUNT_INVALID;
|
2016-10-05 14:27:02 +00:00
|
|
|
});
|
|
|
|
return matching_iter != range.second ? matching_iter : texture_pool.end();
|
|
|
|
}
|
|
|
|
|
2016-12-25 17:48:19 +00:00
|
|
|
TextureCacheBase::TexAddrCache::iterator
|
2017-04-23 04:44:34 +00:00
|
|
|
TextureCacheBase::GetTexCacheIter(TextureCacheBase::TCacheEntry* entry)
|
2016-03-26 02:43:32 +00:00
|
|
|
{
|
2016-12-25 17:48:19 +00:00
|
|
|
auto iter_range = textures_by_address.equal_range(entry->addr);
|
|
|
|
TexAddrCache::iterator iter = iter_range.first;
|
2016-06-24 08:43:46 +00:00
|
|
|
while (iter != iter_range.second)
|
|
|
|
{
|
|
|
|
if (iter->second == entry)
|
|
|
|
{
|
|
|
|
return iter;
|
|
|
|
}
|
|
|
|
++iter;
|
|
|
|
}
|
|
|
|
return textures_by_address.end();
|
2016-03-26 02:43:32 +00:00
|
|
|
}
|
|
|
|
|
2016-12-26 17:41:34 +00:00
|
|
|
std::pair<TextureCacheBase::TexAddrCache::iterator, TextureCacheBase::TexAddrCache::iterator>
|
|
|
|
TextureCacheBase::FindOverlappingTextures(u32 addr, u32 size_in_bytes)
|
|
|
|
{
|
|
|
|
// We index by the starting address only, so there is no way to query all textures
|
|
|
|
// which end after the given addr. But the GC textures have a limited size, so we
|
|
|
|
// look for all textures which have a start address bigger than addr minus the maximal
|
|
|
|
// texture size. But this yields false-positives which must be checked later on.
|
|
|
|
|
|
|
|
// 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);
|
|
|
|
|
|
|
|
return std::make_pair(begin, end);
|
|
|
|
}
|
|
|
|
|
2016-12-25 17:48:19 +00:00
|
|
|
TextureCacheBase::TexAddrCache::iterator
|
|
|
|
TextureCacheBase::InvalidateTexture(TexAddrCache::iterator iter)
|
2015-02-22 17:42:19 +00:00
|
|
|
{
|
2016-06-24 08:43:46 +00:00
|
|
|
if (iter == textures_by_address.end())
|
|
|
|
return textures_by_address.end();
|
2016-03-26 02:43:32 +00:00
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
TCacheEntry* entry = iter->second;
|
2015-06-09 19:45:09 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
if (entry->textures_by_hash_iter != textures_by_hash.end())
|
|
|
|
{
|
|
|
|
textures_by_hash.erase(entry->textures_by_hash_iter);
|
|
|
|
entry->textures_by_hash_iter = textures_by_hash.end();
|
|
|
|
}
|
2014-06-11 23:04:42 +00:00
|
|
|
|
2017-06-29 21:09:32 +00:00
|
|
|
for (size_t i = 0; i < bound_textures.size(); ++i)
|
|
|
|
{
|
|
|
|
// If the entry is currently bound and not invalidated, keep it, but mark it as invalidated.
|
|
|
|
// This way it can still be used via tmem cache emulation, but nothing else.
|
|
|
|
// Spyro: A Hero's Tail is known for using such overwritten textures.
|
|
|
|
if (bound_textures[i] == entry && IsValidBindPoint(static_cast<u32>(i)))
|
|
|
|
{
|
|
|
|
bound_textures[i]->tmem_only = true;
|
|
|
|
return ++iter;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
auto config = entry->texture->GetConfig();
|
|
|
|
texture_pool.emplace(config, TexPoolEntry(std::move(entry->texture)));
|
2015-06-09 19:45:09 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
return textures_by_address.erase(iter);
|
2014-06-11 23:04:42 +00:00
|
|
|
}
|
2015-09-04 14:45:29 +00:00
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
u32 TextureCacheBase::TCacheEntry::BytesPerRow() const
|
2015-09-04 14:45:29 +00:00
|
|
|
{
|
2017-07-30 19:45:55 +00:00
|
|
|
const u32 blockW = TexDecoder_GetBlockWidthInTexels(format.texfmt);
|
2015-10-19 16:00:29 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
// Round up source height to multiple of block size
|
2016-11-27 10:56:22 +00:00
|
|
|
const u32 actualWidth = Common::AlignUp(native_width, blockW);
|
2015-09-04 14:45:29 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
const u32 numBlocksX = actualWidth / blockW;
|
2015-09-04 14:45:29 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
// RGBA takes two cache lines per block; all others take one
|
2017-07-30 19:45:55 +00:00
|
|
|
const u32 bytes_per_block = format == TextureFormat::RGBA8 ? 64 : 32;
|
2015-10-19 16:00:29 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
return numBlocksX * bytes_per_block;
|
2015-09-04 14:45:29 +00:00
|
|
|
}
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
u32 TextureCacheBase::TCacheEntry::NumBlocksY() const
|
2015-09-04 14:45:29 +00:00
|
|
|
{
|
2017-07-30 19:45:55 +00:00
|
|
|
u32 blockH = TexDecoder_GetBlockHeightInTexels(format.texfmt);
|
2016-06-24 08:43:46 +00:00
|
|
|
// Round up source height to multiple of block size
|
2017-07-03 02:24:20 +00:00
|
|
|
u32 actualHeight = Common::AlignUp(static_cast<unsigned int>(native_height * y_scale), blockH);
|
2015-09-04 14:45:29 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
return actualHeight / blockH;
|
2015-09-04 14:45:29 +00:00
|
|
|
}
|
|
|
|
|
2017-06-26 17:06:50 +00:00
|
|
|
void TextureCacheBase::TCacheEntry::SetXfbCopy(u32 stride)
|
|
|
|
{
|
|
|
|
is_efb_copy = false;
|
|
|
|
is_xfb_copy = true;
|
|
|
|
memory_stride = stride;
|
|
|
|
|
|
|
|
_assert_msg_(VIDEO, memory_stride >= BytesPerRow(), "Memory stride is too small");
|
|
|
|
|
|
|
|
size_in_bytes = memory_stride * NumBlocksY();
|
|
|
|
}
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
void TextureCacheBase::TCacheEntry::SetEfbCopy(u32 stride)
|
2015-09-04 14:45:29 +00:00
|
|
|
{
|
2016-06-24 08:43:46 +00:00
|
|
|
is_efb_copy = true;
|
2017-06-26 17:06:50 +00:00
|
|
|
is_xfb_copy = false;
|
2016-06-24 08:43:46 +00:00
|
|
|
memory_stride = stride;
|
2015-09-04 14:45:29 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
_assert_msg_(VIDEO, memory_stride >= BytesPerRow(), "Memory stride is too small");
|
2015-09-04 14:45:29 +00:00
|
|
|
|
2016-06-24 08:43:46 +00:00
|
|
|
size_in_bytes = memory_stride * NumBlocksY();
|
2015-09-04 14:45:29 +00:00
|
|
|
}
|
2015-09-05 14:03:49 +00:00
|
|
|
|
2017-06-26 17:06:50 +00:00
|
|
|
void TextureCacheBase::TCacheEntry::SetNotCopy()
|
|
|
|
{
|
|
|
|
is_xfb_copy = false;
|
|
|
|
is_efb_copy = false;
|
|
|
|
}
|
|
|
|
|
2017-05-29 22:02:09 +00:00
|
|
|
int TextureCacheBase::TCacheEntry::HashSampleSize() const
|
|
|
|
{
|
|
|
|
if (should_force_safe_hashing)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return g_ActiveConfig.iSafeTextureCache_ColorSamples;
|
|
|
|
}
|
|
|
|
|
2017-04-23 04:44:34 +00:00
|
|
|
u64 TextureCacheBase::TCacheEntry::CalculateHash() const
|
2015-09-13 11:30:56 +00:00
|
|
|
{
|
2016-06-24 08:43:46 +00:00
|
|
|
u8* ptr = Memory::GetPointer(addr);
|
|
|
|
if (memory_stride == BytesPerRow())
|
|
|
|
{
|
2017-05-29 22:02:09 +00:00
|
|
|
return GetHash64(ptr, size_in_bytes, HashSampleSize());
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
u32 blocks = NumBlocksY();
|
|
|
|
u64 temp_hash = size_in_bytes;
|
|
|
|
|
|
|
|
u32 samples_per_row = 0;
|
2017-05-29 22:02:09 +00:00
|
|
|
if (HashSampleSize() != 0)
|
2016-06-24 08:43:46 +00:00
|
|
|
{
|
|
|
|
// Hash at least 4 samples per row to avoid hashing in a bad pattern, like just on the left
|
|
|
|
// side of the efb copy
|
2017-05-29 22:02:09 +00:00
|
|
|
samples_per_row = std::max(HashSampleSize() / blocks, 4u);
|
2016-06-24 08:43:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (u32 i = 0; i < blocks; i++)
|
|
|
|
{
|
|
|
|
// Multiply by a prime number to mix the hash up a bit. This prevents identical blocks from
|
|
|
|
// canceling each other out
|
|
|
|
temp_hash = (temp_hash * 397) ^ GetHash64(ptr, BytesPerRow(), samples_per_row);
|
|
|
|
ptr += memory_stride;
|
|
|
|
}
|
|
|
|
return temp_hash;
|
|
|
|
}
|
2015-09-13 11:30:56 +00:00
|
|
|
}
|