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

VideoCommon: rename TextureCache to TextureCacheBase

This commit is contained in:
Tillmann Karras 2015-11-06 01:28:05 +01:00
parent f26b3708e7
commit 81d9cce70c
14 changed files with 59 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/Core/DolphinWX/Debugger/DebuggerPanel.cpp
View File

@ -337,7 +337,7 @@ void GFXDebuggerPanel::OnClearScreenButton(wxCommandEvent& event)
void GFXDebuggerPanel::OnClearTextureCacheButton(wxCommandEvent& event)
{
TextureCache::Invalidate();
TextureCacheBase::Invalidate();
}
void GFXDebuggerPanel::OnClearVertexShaderCacheButton(wxCommandEvent& event)

6
Source/Core/VideoBackends/D3D/PSTextureEncoder.h
View File

@ -31,9 +31,9 @@ public:
void Init();
void Shutdown();
void Encode(u8* dst, const TextureCache::TCacheEntryBase *texture_entry,
PEControl::PixelFormat srcFormat, const EFBRectangle& srcRect,
bool isIntensity, bool scaleByHalf);
void Encode(u8* dst, const TextureCacheBase::TCacheEntryBase* texture_entry,
PEControl::PixelFormat srcFormat, const EFBRectangle& srcRect,
bool isIntensity, bool scaleByHalf);
private:
bool m_ready;

4
Source/Core/VideoBackends/D3D/Render.cpp
View File

@ -878,11 +878,11 @@ void Renderer::SwapImpl(u32 xfbAddr, u32 fbWidth, u32 fbStride, u32 fbHeight, co
OSD::DrawMessages();
D3D::EndFrame();
TextureCache::Cleanup(frameCount);
TextureCacheBase::Cleanup(frameCount);
// Enable configuration changes
UpdateActiveConfig();
TextureCache::OnConfigChanged(g_ActiveConfig);
TextureCacheBase::OnConfigChanged(g_ActiveConfig);
SetWindowSize(fbStride, fbHeight);

2
Source/Core/VideoBackends/D3D/TextureCache.cpp
View File

@ -145,7 +145,7 @@ void TextureCache::TCacheEntry::Load(unsigned int width, unsigned int height,
D3D::ReplaceRGBATexture2D(texture->GetTex(), TextureCache::temp, width, height, expanded_width, level, usage);
}
TextureCache::TCacheEntryBase* TextureCache::CreateTexture(const TCacheEntryConfig& config)
TextureCacheBase::TCacheEntryBase* TextureCache::CreateTexture(const TCacheEntryConfig& config)
{
if (config.rendertarget)
{

2
Source/Core/VideoBackends/D3D/TextureCache.h
View File

@ -10,7 +10,7 @@
namespace DX11
{
class TextureCache : public ::TextureCache
class TextureCache : public TextureCacheBase
{
public:
TextureCache();

2
Source/Core/VideoBackends/D3D/TextureEncoder.h
View File

@ -26,7 +26,7 @@ public:
virtual void Init() = 0;
virtual void Shutdown() = 0;
// Returns size in bytes of encoded block of memory
virtual void Encode(u8* dst, const TextureCache::TCacheEntryBase *texture_entry,
virtual void Encode(u8* dst, const TextureCacheBase::TCacheEntryBase* texture_entry,
PEControl::PixelFormat srcFormat, const EFBRectangle& srcRect,
bool isIntensity, bool scaleByHalf) = 0;

2
Source/Core/VideoBackends/OGL/TextureCache.h
View File

@ -15,7 +15,7 @@
namespace OGL
{
class TextureCache : public ::TextureCache
class TextureCache : public TextureCacheBase
{
public:
TextureCache();

2
Source/Core/VideoBackends/OGL/TextureConverter.h
View File

@ -26,7 +26,7 @@ void EncodeToRamYUYV(GLuint srcTexture, const TargetRectangle& sourceRc,
void DecodeToTexture(u32 xfbAddr, int srcWidth, int srcHeight, GLuint destTexture);
// returns size of the encoded data (in bytes)
void EncodeToRamFromTexture(u8 *dest_ptr, const TextureCache::TCacheEntryBase *texture_entry,
void EncodeToRamFromTexture(u8* dest_ptr, const TextureCacheBase::TCacheEntryBase* texture_entry,
GLuint source_texture, bool bFromZBuffer, bool bIsIntensityFmt, int bScaleByHalf, const EFBRectangle& source);
}

6
Source/Core/VideoCommon/BPStructs.cpp
View File

@ -224,9 +224,9 @@ static void BPWritten(const BPCmd& bp)
if (PE_copy.copy_to_xfb == 0)
{
// bpmem.zcontrol.pixel_format to PEControl::Z24 is when the game wants to copy from ZBuffer (Zbuffer uses 24-bit Format)
TextureCache::CopyRenderTargetToTexture(destAddr, PE_copy.tp_realFormat(), destStride,
bpmem.zcontrol.pixel_format, srcRect,
!!PE_copy.intensity_fmt, !!PE_copy.half_scale);
TextureCacheBase::CopyRenderTargetToTexture(destAddr, PE_copy.tp_realFormat(), destStride,
bpmem.zcontrol.pixel_format, srcRect,
!!PE_copy.intensity_fmt, !!PE_copy.half_scale);
}
else
{

2
Source/Core/VideoCommon/MainBase.cpp
View File

@ -227,7 +227,7 @@ void VideoBackendHardware::CheckInvalidState()
m_invalid = false;
BPReload();
TextureCache::Invalidate();
TextureCacheBase::Invalidate();
}
}

2
Source/Core/VideoCommon/RenderBase.cpp
View File

@ -88,7 +88,7 @@ Renderer::Renderer()
, bLastFrameDumped(false)
{
UpdateActiveConfig();
TextureCache::OnConfigChanged(g_ActiveConfig);
TextureCacheBase::OnConfigChanged(g_ActiveConfig);
#if defined _WIN32 || defined HAVE_LIBAV
bAVIDumping = false;

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

@ -28,25 +28,25 @@ static const int TEXTURE_KILL_THRESHOLD = 64; // Sonic the Fighters (inside Soni
static const int TEXTURE_POOL_KILL_THRESHOLD = 3;
static const int FRAMECOUNT_INVALID = 0;
TextureCache* g_texture_cache;
TextureCacheBase* g_texture_cache;
alignas(16) u8* TextureCache::temp = nullptr;
size_t TextureCache::temp_size;
alignas(16) u8* TextureCacheBase::temp = nullptr;
size_t TextureCacheBase::temp_size;
TextureCache::TexCache TextureCache::textures_by_address;
TextureCache::TexCache TextureCache::textures_by_hash;
TextureCache::TexPool TextureCache::texture_pool;
TextureCache::TCacheEntryBase* TextureCache::bound_textures[8];
TextureCacheBase::TexCache TextureCacheBase::textures_by_address;
TextureCacheBase::TexCache TextureCacheBase::textures_by_hash;
TextureCacheBase::TexPool TextureCacheBase::texture_pool;
TextureCacheBase::TCacheEntryBase* TextureCacheBase::bound_textures[8];
TextureCache::BackupConfig TextureCache::backup_config;
TextureCacheBase::BackupConfig TextureCacheBase::backup_config;
static bool invalidate_texture_cache_requested;
TextureCache::TCacheEntryBase::~TCacheEntryBase()
TextureCacheBase::TCacheEntryBase::~TCacheEntryBase()
{
}
void TextureCache::CheckTempSize(size_t required_size)
void TextureCacheBase::CheckTempSize(size_t required_size)
{
if (required_size <= temp_size)
return;
@ -56,7 +56,7 @@ void TextureCache::CheckTempSize(size_t required_size)
temp = (u8*)AllocateAlignedMemory(temp_size, 16);
}
TextureCache::TextureCache()
TextureCacheBase::TextureCacheBase()
{
temp_size = 2048 * 2048 * 4;
if (!temp)
@ -71,12 +71,12 @@ TextureCache::TextureCache()
invalidate_texture_cache_requested = false;
}
void TextureCache::RequestInvalidateTextureCache()
void TextureCacheBase::RequestInvalidateTextureCache()
{
invalidate_texture_cache_requested = true;
}
void TextureCache::Invalidate()
void TextureCacheBase::Invalidate()
{
UnbindTextures();
@ -94,7 +94,7 @@ void TextureCache::Invalidate()
texture_pool.clear();
}
TextureCache::~TextureCache()
TextureCacheBase::~TextureCacheBase()
{
HiresTexture::Shutdown();
Invalidate();
@ -102,7 +102,7 @@ TextureCache::~TextureCache()
temp = nullptr;
}
void TextureCache::OnConfigChanged(VideoConfig& config)
void TextureCacheBase::OnConfigChanged(VideoConfig& config)
{
if (g_texture_cache)
{
@ -143,7 +143,7 @@ void TextureCache::OnConfigChanged(VideoConfig& config)
backup_config.s_efb_mono_depth = config.bStereoEFBMonoDepth;
}
void TextureCache::Cleanup(int _frameCount)
void TextureCacheBase::Cleanup(int _frameCount)
{
TexCache::iterator iter = textures_by_address.begin();
TexCache::iterator tcend = textures_by_address.end();
@ -201,7 +201,7 @@ void TextureCache::Cleanup(int _frameCount)
}
}
bool TextureCache::TCacheEntryBase::OverlapsMemoryRange(u32 range_address, u32 range_size) const
bool TextureCacheBase::TCacheEntryBase::OverlapsMemoryRange(u32 range_address, u32 range_size) const
{
if (addr + size_in_bytes <= range_address)
return false;
@ -212,7 +212,7 @@ bool TextureCache::TCacheEntryBase::OverlapsMemoryRange(u32 range_address, u32 r
return true;
}
TextureCache::TCacheEntryBase* TextureCache::DoPartialTextureUpdates(TexCache::iterator iter_t)
TextureCacheBase::TCacheEntryBase* TextureCacheBase::DoPartialTextureUpdates(TexCache::iterator iter_t)
{
TCacheEntryBase* entry_to_update = iter_t->second;
const bool isPaletteTexture = (entry_to_update->format == GX_TF_C4
@ -272,7 +272,7 @@ TextureCache::TCacheEntryBase* TextureCache::DoPartialTextureUpdates(TexCache::i
}
if (entry_to_update->config.width != w || entry_to_update->config.height != h)
{
TextureCache::TCacheEntryConfig newconfig;
TextureCacheBase::TCacheEntryConfig newconfig;
newconfig.width = w;
newconfig.height = h;
newconfig.rendertarget = true;
@ -315,7 +315,7 @@ TextureCache::TCacheEntryBase* TextureCache::DoPartialTextureUpdates(TexCache::i
return entry_to_update;
}
void TextureCache::DumpTexture(TCacheEntryBase* entry, std::string basename, unsigned int level)
void TextureCacheBase::DumpTexture(TCacheEntryBase* entry, std::string basename, unsigned int level)
{
std::string szDir = File::GetUserPath(D_DUMPTEXTURES_IDX) +
SConfig::GetInstance().m_strUniqueID;
@ -339,8 +339,8 @@ static u32 CalculateLevelSize(u32 level_0_size, u32 level)
return (level_0_size + ((1 << level) - 1)) >> level;
}
// Used by TextureCache::Load
TextureCache::TCacheEntryBase* TextureCache::ReturnEntry(unsigned int stage, TCacheEntryBase* entry)
// Used by TextureCacheBase::Load
TextureCacheBase::TCacheEntryBase* TextureCacheBase::ReturnEntry(unsigned int stage, TCacheEntryBase* entry)
{
entry->frameCount = FRAMECOUNT_INVALID;
bound_textures[stage] = entry;
@ -350,7 +350,7 @@ TextureCache::TCacheEntryBase* TextureCache::ReturnEntry(unsigned int stage, TCa
return entry;
}
void TextureCache::BindTextures()
void TextureCacheBase::BindTextures()
{
for (int i = 0; i < 8; ++i)
{
@ -359,12 +359,12 @@ void TextureCache::BindTextures()
}
}
void TextureCache::UnbindTextures()
void TextureCacheBase::UnbindTextures()
{
std::fill(std::begin(bound_textures), std::end(bound_textures), nullptr);
}
TextureCache::TCacheEntryBase* TextureCache::Load(const u32 stage)
TextureCacheBase::TCacheEntryBase* TextureCacheBase::Load(const u32 stage)
{
const FourTexUnits &tex = bpmem.tex[stage >> 2];
const u32 id = stage & 3;
@ -724,8 +724,8 @@ TextureCache::TCacheEntryBase* TextureCache::Load(const u32 stage)
return ReturnEntry(stage, entry);
}
void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat, u32 dstStride, PEControl::PixelFormat srcFormat,
const EFBRectangle& srcRect, bool isIntensity, bool scaleByHalf)
void TextureCacheBase::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat, u32 dstStride, PEControl::PixelFormat srcFormat,
const EFBRectangle& srcRect, bool isIntensity, bool scaleByHalf)
{
// Emulation methods:
//
@ -1101,10 +1101,10 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
textures_by_address.emplace((u64)dstAddr, entry);
}
TextureCache::TCacheEntryBase* TextureCache::AllocateTexture(const TCacheEntryConfig& config)
TextureCacheBase::TCacheEntryBase* TextureCacheBase::AllocateTexture(const TCacheEntryConfig& config)
{
TexPool::iterator iter = texture_pool.find(config);
TextureCache::TCacheEntryBase* entry;
TextureCacheBase::TCacheEntryBase* entry;
if (iter != texture_pool.end())
{
entry = iter->second;
@ -1120,7 +1120,7 @@ TextureCache::TCacheEntryBase* TextureCache::AllocateTexture(const TCacheEntryCo
return entry;
}
TextureCache::TexCache::iterator TextureCache::FreeTexture(TexCache::iterator iter)
TextureCacheBase::TexCache::iterator TextureCacheBase::FreeTexture(TexCache::iterator iter)
{
TCacheEntryBase* entry = iter->second;
@ -1136,7 +1136,7 @@ TextureCache::TexCache::iterator TextureCache::FreeTexture(TexCache::iterator it
return textures_by_address.erase(iter);
}
u32 TextureCache::TCacheEntryBase::BytesPerRow() const
u32 TextureCacheBase::TCacheEntryBase::BytesPerRow() const
{
const u32 blockW = TexDecoder_GetBlockWidthInTexels(format);
@ -1151,7 +1151,7 @@ u32 TextureCache::TCacheEntryBase::BytesPerRow() const
return numBlocksX * bytes_per_block;
}
u32 TextureCache::TCacheEntryBase::NumBlocksY() const
u32 TextureCacheBase::TCacheEntryBase::NumBlocksY() const
{
u32 blockH = TexDecoder_GetBlockHeightInTexels(format);
// Round up source height to multiple of block size
@ -1160,7 +1160,7 @@ u32 TextureCache::TCacheEntryBase::NumBlocksY() const
return actualHeight / blockH;
}
void TextureCache::TCacheEntryBase::SetEfbCopy(u32 stride)
void TextureCacheBase::TCacheEntryBase::SetEfbCopy(u32 stride)
{
is_efb_copy = true;
memory_stride = stride;
@ -1171,7 +1171,7 @@ void TextureCache::TCacheEntryBase::SetEfbCopy(u32 stride)
}
// Fill gamecube memory backing this texture with zeros.
void TextureCache::TCacheEntryBase::Zero(u8* ptr)
void TextureCacheBase::TCacheEntryBase::Zero(u8* ptr)
{
for (u32 i = 0; i < NumBlocksY(); i++)
{
@ -1180,7 +1180,7 @@ void TextureCache::TCacheEntryBase::Zero(u8* ptr)
}
}
u64 TextureCache::TCacheEntryBase::CalculateHash() const
u64 TextureCacheBase::TCacheEntryBase::CalculateHash() const
{
u8* ptr = Memory::GetPointer(addr);
if (memory_stride == BytesPerRow())

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

@ -17,7 +17,7 @@
struct VideoConfig;
class TextureCache
class TextureCacheBase
{
public:
struct TCacheEntryConfig
@ -35,7 +35,7 @@ public:
struct Hasher : std::hash<u64>
{
size_t operator()(const TextureCache::TCacheEntryConfig& c) const
size_t operator()(const TextureCacheBase::TCacheEntryConfig& c) const
{
u64 id = (u64)c.rendertarget << 63 | (u64)c.layers << 48 | (u64)c.levels << 32 | (u64)c.height << 16 | (u64)c.width;
return std::hash<u64>::operator()(id);
@ -118,7 +118,7 @@ public:
u64 CalculateHash() const;
};
virtual ~TextureCache(); // needs virtual for DX11 dtor
virtual ~TextureCacheBase(); // needs virtual for DX11 dtor
static void OnConfigChanged(VideoConfig& config);
@ -144,7 +144,7 @@ public:
virtual void ConvertTexture(TCacheEntryBase* entry, TCacheEntryBase* unconverted, void* palette, TlutFormat format) = 0;
protected:
TextureCache();
TextureCacheBase();
alignas(16) static u8* temp;
static size_t temp_size;
@ -180,4 +180,4 @@ private:
} backup_config;
};
extern TextureCache *g_texture_cache;
extern TextureCacheBase* g_texture_cache;

6
Source/Core/VideoCommon/VertexManagerBase.cpp
View File

@ -211,10 +211,10 @@ void VertexManagerBase::Flush()
if (bpmem.tevind[i].IsActive() && bpmem.tevind[i].bt < bpmem.genMode.numindstages)
usedtextures[bpmem.tevindref.getTexMap(bpmem.tevind[i].bt)] = true;
TextureCache::UnbindTextures();
TextureCacheBase::UnbindTextures();
for (unsigned int i : usedtextures)
{
const TextureCache::TCacheEntryBase* tentry = TextureCache::Load(i);
const TextureCacheBase::TCacheEntryBase* tentry = TextureCacheBase::Load(i);
if (tentry)
{
@ -226,7 +226,7 @@ void VertexManagerBase::Flush()
ERROR_LOG(VIDEO, "error loading texture");
}
}
TextureCache::BindTextures();
TextureCacheBase::BindTextures();
}
// set global vertex constants