From 3d9c35f58e84aa2c1b69bf4dfe381a9b526a3dd2 Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@googlemail.com>
Date: Sat, 10 Dec 2011 16:08:26 +0100
Subject: VideoCommon: Fix upper and lower depth bytes being switched when
 performing Z16L EFB copies (EFB to texture only).

Fixes issue 4989.
Fixes issue 5056.
---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index d3b7ca14ba..3550227389 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -429,7 +429,7 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 	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[0] = ColorMask[1] = ColorMask[2] = ColorMask[3] = 255.0f;
 	ColorMask[4] = ColorMask[5] = ColorMask[6] = ColorMask[7] = 1.0f / 255.0f;
 	unsigned int cbufid = -1;
 
@@ -437,7 +437,7 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 	{
 		switch (dstFormat)
 		{
-		case 0: // Z4				
+		case 0: // Z4
 			colmat[3] = colmat[7] = colmat[11] = colmat[15] = 1.0f;
 			cbufid = 0;
 			break;
@@ -447,7 +447,7 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 			cbufid = 1;
 			break;
 
-		case 3: // Z16 
+		case 3: // Z16
 			colmat[1] = colmat[5] = colmat[9] = colmat[12] = 1.0f;
 			cbufid = 24;
 			break;
@@ -472,8 +472,10 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 			cbufid = 5;
 			break;
 
-		case 12: // Z16L
-			colmat[2] = colmat[6] = colmat[10] = colmat[13] = 1.0f;
+		case 12: // Z16L - copy lower 16 depth bits
+			// 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 = 6;
 			break;
 
@@ -483,7 +485,6 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 			cbufid = 7;
 			break;
 		}
-		
 	}
 	else if (isIntensity) 
 	{
-- 
cgit v1.2.3


From c5008fe9dea7baf3368e214fe70e148d3bcca83b Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Mon, 26 Dec 2011 17:35:27 +0100
Subject: TextureCache: Renaming some variables OGL: Fix a possible bug at
 texture dumping OGL: Add a TODO about a possible bug

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 30 ++++++++++++------------
 1 file changed, 15 insertions(+), 15 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index 3550227389..b56dc171aa 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -266,7 +266,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		}
 
 		if (((entry->isRenderTarget || entry->isDynamic) && hash_value == entry->hash && address == entry->addr) 
-			|| ((address == entry->addr) && (hash_value == entry->hash) && full_format == entry->format && entry->mipLevels == maxlevel))
+			|| ((address == entry->addr) && (hash_value == entry->hash) && full_format == entry->format && entry->num_mipmaps == maxlevel))
 		{
 			entry->isDynamic = false;
 			goto return_entry;
@@ -279,8 +279,8 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 			texture_is_dynamic = (entry->isRenderTarget || entry->isDynamic) && !g_ActiveConfig.bCopyEFBToTexture;
 
 			if (!entry->isRenderTarget &&
-				((!entry->isDynamic && width == entry->realW && height == entry->realH && full_format == entry->format && entry->mipLevels == maxlevel)
-				|| (entry->isDynamic && entry->realW == width && entry->realH == height)))
+				((!entry->isDynamic && width == entry->native_width && height == entry->native_height && full_format == entry->format && entry->num_mipmaps == maxlevel)
+				|| (entry->isDynamic && entry->native_width == width && entry->native_height == height)))
 			{
 				// reuse the texture
 			}
@@ -332,7 +332,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		// Sometimes, we can get around recreating a texture if only the number of mip levels gets changes
 		// e.g. if our texture cache entry got too many mipmap levels we can limit the number of used levels by setting the appropriate render states
 		// Thus, we don't update this member for every Load, but just whenever the texture gets recreated
-		entry->mipLevels = maxlevel;
+		entry->num_mipmaps = maxlevel;
 
 		GFX_DEBUGGER_PAUSE_AT(NEXT_NEW_TEXTURE, true);
 	}
@@ -341,11 +341,11 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	entry->format = full_format;
 	entry->size_in_bytes = texture_size;
 
-	entry->virtualW = width;
-	entry->virtualH = height;
+	entry->native_width = nativeW;
+	entry->native_height = nativeH;
 
-	entry->realW = nativeW;
-	entry->realH = nativeH;
+	entry->virtual_width = width;
+	entry->virtual_height = height;
 		
 	entry->isRenderTarget = false;
 	entry->isNonPow2 = false;
@@ -633,8 +633,8 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 	TCacheEntryBase *entry = textures[dstAddr];
 	if (entry)
 	{
-		if ((entry->isRenderTarget && entry->virtualW == scaled_tex_w && entry->virtualH == scaled_tex_h) 
-			|| (entry->isDynamic && entry->realW == tex_w && entry->realH == tex_h))
+		if ((entry->isRenderTarget && entry->virtual_width == scaled_tex_w && entry->virtual_height == scaled_tex_h) 
+			|| (entry->isDynamic && entry->native_width == tex_w && entry->native_height == tex_h))
 		{
 			texture_is_dynamic = entry->isDynamic;
 		}
@@ -660,14 +660,14 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 		entry->addr = dstAddr;
 		entry->hash = 0;
 
-		entry->realW = tex_w;
-		entry->realH = tex_h;
+		entry->native_width = tex_w;
+		entry->native_height = tex_h;
 
-		entry->virtualW = scaled_tex_w;
-		entry->virtualH = scaled_tex_h;
+		entry->virtual_width = scaled_tex_w;
+		entry->virtual_height = scaled_tex_h;
 
 		entry->format = dstFormat;
-		entry->mipLevels = 0;
+		entry->num_mipmaps = 0;
 
 		entry->isRenderTarget = true;
 		entry->isNonPow2 = true;
-- 
cgit v1.2.3


From 94a8536b8cc44ab1435982695bc4a245e9f38f75 Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Mon, 26 Dec 2011 18:05:01 +0100
Subject: TextureCacheBase: Simplify texture cache entry initialization

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 52 ++++++++----------------
 1 file changed, 17 insertions(+), 35 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index b56dc171aa..a5db110c7a 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -135,7 +135,7 @@ void TextureCache::MakeRangeDynamic(u32 start_address, u32 size)
 		const int rangePosition = iter->second->IntersectsMemoryRange(start_address, size);
 		if (0 == rangePosition)
 		{
-			iter->second->hash = 0;
+			iter->second->SetHashes(TEXHASH_INVALID);
 		}
 	}
 }
@@ -190,8 +190,8 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	const unsigned int nativeH = height;
 	bool isPow2;
 
-	u64 hash_value = 0;
-	u64 texHash = 0;
+	u64 hash_value = TEXHASH_INVALID;
+	u64 texHash = TEXHASH_INVALID;
 	u32 texID = address;
 	u32 full_format = texformat;
 	const u32 texture_size = TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, texformat);
@@ -252,7 +252,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 				}
 				else
 				{
-					hash_value = 0;
+					hash_value = TEXHASH_INVALID;
 				}
 			}
 			else
@@ -262,7 +262,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		}
 		else if ((entry->isRenderTarget || entry->isDynamic) && g_ActiveConfig.bCopyEFBToTexture)
 		{
-			hash_value = 0;
+			hash_value = TEXHASH_INVALID;
 		}
 
 		if (((entry->isRenderTarget || entry->isDynamic) && hash_value == entry->hash && address == entry->addr) 
@@ -332,24 +332,15 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		// Sometimes, we can get around recreating a texture if only the number of mip levels gets changes
 		// e.g. if our texture cache entry got too many mipmap levels we can limit the number of used levels by setting the appropriate render states
 		// Thus, we don't update this member for every Load, but just whenever the texture gets recreated
-		entry->num_mipmaps = maxlevel;
+		entry->num_mipmaps = maxlevel; // TODO: Does this actually work? We can't really adjust mipmap settings per-stage...
 
 		GFX_DEBUGGER_PAUSE_AT(NEXT_NEW_TEXTURE, true);
 	}
 
-	entry->addr = address;
-	entry->format = full_format;
-	entry->size_in_bytes = texture_size;
-
-	entry->native_width = nativeW;
-	entry->native_height = nativeH;
-
-	entry->virtual_width = width;
-	entry->virtual_height = height;
-		
-	entry->isRenderTarget = false;
+	entry->SetGeneralParameters(address, texture_size, full_format, entry->num_mipmaps);
+	entry->SetDimensions(nativeW, nativeH, width, height);
+	entry->SetEFBCopyParameters(false, texture_is_dynamic);
 	entry->isNonPow2 = false;
-	entry->isDynamic = texture_is_dynamic;
 
 	entry->oldpixel = *(u32*)ptr;
 
@@ -472,9 +463,9 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 			cbufid = 5;
 			break;
 
-		case 12: // Z16L - copy lower 16 depth bits
-			// 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
+		case 12: // Z16L - copy lower 16 depth bits
+			// 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 = 6;
 			break;
@@ -657,21 +648,12 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 		// create the texture
 		textures[dstAddr] = entry = g_texture_cache->CreateRenderTargetTexture(scaled_tex_w, scaled_tex_h);
 
-		entry->addr = dstAddr;
-		entry->hash = 0;
-
-		entry->native_width = tex_w;
-		entry->native_height = tex_h;
-
-		entry->virtual_width = scaled_tex_w;
-		entry->virtual_height = scaled_tex_h;
-
-		entry->format = dstFormat;
-		entry->num_mipmaps = 0;
-
-		entry->isRenderTarget = true;
+		// TODO: Using the wrong dstFormat, dumb...
+		entry->SetGeneralParameters(dstAddr, 0, dstFormat, 0);
+		entry->SetDimensions(tex_w, tex_h, scaled_tex_w, scaled_tex_h);
+		entry->SetEFBCopyParameters(true, false);
+		entry->SetHashes(TEXHASH_INVALID);
 		entry->isNonPow2 = true;
-		entry->isDynamic = false;
 	}
 
 	entry->frameCount = frameCount;
-- 
cgit v1.2.3


From 9c39952c3415e1592098b46c801d668b3049fa83 Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Mon, 26 Dec 2011 18:33:05 +0100
Subject: TextureCacheBase: Kill deprecated entry member isNonPow2
 TextureCacheBase: Add a TODO about a potential bug

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index a5db110c7a..8bca9e36d9 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -93,7 +93,7 @@ void TextureCache::Cleanup()
 		tcend = textures.end();
 	while (iter != tcend)
 	{
-		if (frameCount > TEXTURE_KILL_THRESHOLD + iter->second->frameCount)
+		if (frameCount > TEXTURE_KILL_THRESHOLD + iter->second->frameCount) // TODO: Deleting EFB copies might not be a good idea here...
 		{
 			delete iter->second;
 			textures.erase(iter++);
@@ -340,7 +340,6 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	entry->SetGeneralParameters(address, texture_size, full_format, entry->num_mipmaps);
 	entry->SetDimensions(nativeW, nativeH, width, height);
 	entry->SetEFBCopyParameters(false, texture_is_dynamic);
-	entry->isNonPow2 = false;
 
 	entry->oldpixel = *(u32*)ptr;
 
@@ -653,7 +652,6 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 		entry->SetDimensions(tex_w, tex_h, scaled_tex_w, scaled_tex_h);
 		entry->SetEFBCopyParameters(true, false);
 		entry->SetHashes(TEXHASH_INVALID);
-		entry->isNonPow2 = true;
 	}
 
 	entry->frameCount = frameCount;
-- 
cgit v1.2.3


From 8bc9e443fd5ceb7b5f4b11ccf600d6ca5f332427 Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Mon, 26 Dec 2011 18:45:22 +0100
Subject: TextureCacheBase: De-uglify entry lookup a bit

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 38 +++++++++---------------
 1 file changed, 14 insertions(+), 24 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index 8bca9e36d9..e2d74e18e5 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -88,9 +88,8 @@ TextureCache::~TextureCache()
 
 void TextureCache::Cleanup()
 {
-	TexCache::iterator
-		iter = textures.begin(),
-		tcend = textures.end();
+	TexCache::iterator iter = textures.begin();
+	TexCache::iterator tcend = textures.end();
 	while (iter != tcend)
 	{
 		if (frameCount > TEXTURE_KILL_THRESHOLD + iter->second->frameCount) // TODO: Deleting EFB copies might not be a good idea here...
@@ -236,34 +235,25 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	TCacheEntryBase *entry = textures[texID];
 	if (entry)
 	{
-		if (!g_ActiveConfig.bSafeTextureCache)
+		if (g_ActiveConfig.bSafeTextureCache)
+		{
+			if (g_ActiveConfig.bCopyEFBToTexture && (entry->isRenderTarget || entry->isDynamic))
+				hash_value = TEXHASH_INVALID;
+		}
+		else
 		{
-			if (entry->isRenderTarget || entry->isDynamic)
+			if (!(entry->isRenderTarget || entry->isDynamic))
+				hash_value = *(u32*)ptr;
+			else if (g_ActiveConfig.bCopyEFBToTexture)
+				hash_value = TEXHASH_INVALID;
+			else
 			{
-				if (!g_ActiveConfig.bCopyEFBToTexture)
-				{
 					hash_value = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
 
 					if (isPaletteTexture)
-					{
-						hash_value ^= GetHash64(&texMem[tlutaddr], palette_size,
-							g_ActiveConfig.iSafeTextureCache_ColorSamples);
-					}
-				}
-				else
-				{
-					hash_value = TEXHASH_INVALID;
-				}
-			}
-			else
-			{
-				hash_value = *(u32*)ptr;
+						hash_value ^= GetHash64(&texMem[tlutaddr], palette_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
 			}
 		}
-		else if ((entry->isRenderTarget || entry->isDynamic) && g_ActiveConfig.bCopyEFBToTexture)
-		{
-			hash_value = TEXHASH_INVALID;
-		}
 
 		if (((entry->isRenderTarget || entry->isDynamic) && hash_value == entry->hash && address == entry->addr) 
 			|| ((address == entry->addr) && (hash_value == entry->hash) && full_format == entry->format && entry->num_mipmaps == maxlevel))
-- 
cgit v1.2.3


From dcf18fbaaf20cf1eade8c76eccd7fcd279b43957 Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Mon, 26 Dec 2011 19:17:04 +0100
Subject: TextureCacheBase: Force autogenerating mipmaps if custom textures are
 used

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index e2d74e18e5..afe4ce8abc 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -282,7 +282,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 			}
 		}
 	}
-	
+
 	if (g_ActiveConfig.bHiresTextures)
 	{
 		// Load Custom textures
@@ -298,16 +298,14 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		{
 			expandedWidth = width = newWidth;
 			expandedHeight = height = newHeight;
-
-			// TODO: shouldn't generating mips be forced on now?
-			// native mips with a custom texture wouldn't make sense
 		}
 	}
 
 	if (pcfmt == PC_TEX_FMT_NONE)
 		pcfmt = TexDecoder_Decode(temp, ptr, expandedWidth,
-			expandedHeight, texformat, tlutaddr, tlutfmt, g_ActiveConfig.backend_info.bUseRGBATextures);
+					expandedHeight, texformat, tlutaddr, tlutfmt, g_ActiveConfig.backend_info.bUseRGBATextures);
 
+	UseNativeMips = UseNativeMips && (width == nativeW && height == nativeH); // Only load native mips if their dimensions fit to our virtual texture dimensions
 	isPow2 = !((width & (width - 1)) || (height & (height - 1)));
 	texLevels = (isPow2 && UseNativeMips && maxlevel) ?
 		GetPow2(std::max(width, height)) : !isPow2;
@@ -330,13 +328,11 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	entry->SetGeneralParameters(address, texture_size, full_format, entry->num_mipmaps);
 	entry->SetDimensions(nativeW, nativeH, width, height);
 	entry->SetEFBCopyParameters(false, texture_is_dynamic);
-
 	entry->oldpixel = *(u32*)ptr;
 
 	if (g_ActiveConfig.bSafeTextureCache || entry->isDynamic)
 		entry->hash = hash_value;
 	else
-		// don't like rand() here
 		entry->hash = *(u32*)ptr = (u32)(((double)rand() / RAND_MAX) * 0xFFFFFFFF);
 
 	// load texture
-- 
cgit v1.2.3


From f68ee87e0e03b909d66a8a333297499d357aa22b Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Mon, 26 Dec 2011 19:45:13 +0100
Subject: TextureCacheBase: De-uglify texcache entry lookup even more +
 documentation

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 48 ++++++++++++++----------
 1 file changed, 29 insertions(+), 19 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index afe4ce8abc..1c6f8a4718 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -235,6 +235,9 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	TCacheEntryBase *entry = textures[texID];
 	if (entry)
 	{
+		// 1. Adjust reference hash:
+		// safe texcache: reference hash was calculated above for normal textures. 0 for virtual EFB copies.
+		// unsafe texcache: 0 for virtual EFB copies. Safe hash for dynamic EFB copies. First pixel for normal textures.
 		if (g_ActiveConfig.bSafeTextureCache)
 		{
 			if (g_ActiveConfig.bCopyEFBToTexture && (entry->isRenderTarget || entry->isDynamic))
@@ -255,31 +258,38 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 			}
 		}
 
-		if (((entry->isRenderTarget || entry->isDynamic) && hash_value == entry->hash && address == entry->addr) 
-			|| ((address == entry->addr) && (hash_value == entry->hash) && full_format == entry->format && entry->num_mipmaps == maxlevel))
+		// 2. a) For EFB copies, only the hash and the texture address need to match
+		if ((entry->isRenderTarget || entry->isDynamic) && hash_value == entry->hash && address == entry->addr)
 		{
+			// TODO: Print a warning if the format changes! In this case, we could reinterpret the internal texture object data to the new pixel format (similiar to what is already being done in Renderer::ReinterpretPixelFormat())
 			entry->isDynamic = false;
 			goto return_entry;
 		}
+
+		// 2. b) For normal textures, all texture parameters need to match
+		if (address == entry->addr && hash_value == entry->hash && full_format == entry->format &&
+			entry->num_mipmaps == maxlevel && entry->native_width == nativeW && entry->native_height == nativeH)
+		{
+			goto return_entry;
+		}
+
+		// 3. If we reach this line, we'll have to upload the new texture data to VRAM.
+		//    If we're lucky, the texture parameters didn't change and we can reuse the internal texture object instead of destroying and recreating it.
+		texture_is_dynamic = (entry->isRenderTarget || entry->isDynamic) && !g_ActiveConfig.bCopyEFBToTexture;
+
+		// TODO: Don't we need to force texture decoding to RGBA8 for dynamic EFB copies?
+		// TODO: Actually, it should be enough if the internal texture format matches...
+		if (!entry->isRenderTarget &&
+			((!entry->isDynamic && width == entry->native_width && height == entry->native_height && full_format == entry->format && entry->num_mipmaps == maxlevel)
+			|| (entry->isDynamic && entry->native_width == width && entry->native_height == height)))
+		{
+			// reuse the texture
+		}
 		else
 		{
-			// Let's reload the new texture data into the same texture,
-			// instead of destroying it and having to create a new one.
-			// Might speed up movie playback very, very slightly.
-			texture_is_dynamic = (entry->isRenderTarget || entry->isDynamic) && !g_ActiveConfig.bCopyEFBToTexture;
-
-			if (!entry->isRenderTarget &&
-				((!entry->isDynamic && width == entry->native_width && height == entry->native_height && full_format == entry->format && entry->num_mipmaps == maxlevel)
-				|| (entry->isDynamic && entry->native_width == width && entry->native_height == height)))
-			{
-				// reuse the texture
-			}
-			else
-			{
-				// delete the texture and make a new one
-				delete entry;
-				entry = NULL;
-			}
+			// delete the texture and make a new one
+			delete entry;
+			entry = NULL;
 		}
 	}
 
-- 
cgit v1.2.3


From 0c1e015ec3172ecab09f0315b98aeadd1191f4a4 Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Mon, 26 Dec 2011 20:05:32 +0100
Subject: TextureCacheBase: Small change

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index 1c6f8a4718..c29646273a 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -367,7 +367,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 			expandedHeight = (currentHeight + bsh) & (~bsh);
 
 			TexDecoder_Decode(temp, ptr, expandedWidth, expandedHeight, texformat, tlutaddr, tlutfmt, g_ActiveConfig.backend_info.bUseRGBATextures);
-			entry->Load(currentWidth, currentHeight, expandedWidth, level);
+			entry->Load(currentWidth, currentHeight, expandedWidth, level, false);
 
 			ptr += ((std::max(mipWidth, bsw) * std::max(mipHeight, bsh) * bsdepth) >> 1);
 			mipWidth >>= 1;
-- 
cgit v1.2.3


From 93dbd93a8d35e3a87ae1c918369e952be3404b59 Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Mon, 26 Dec 2011 21:11:31 +0100
Subject: TextureCacheBase: More cleanup...

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 53 +++++++++++++-----------
 1 file changed, 28 insertions(+), 25 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index c29646273a..926b86b29a 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -191,10 +191,10 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 
 	u64 hash_value = TEXHASH_INVALID;
 	u64 texHash = TEXHASH_INVALID;
+	u64 tlut_hash = TEXHASH_INVALID;
 	u32 texID = address;
 	u32 full_format = texformat;
 	const u32 texture_size = TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, texformat);
-	const u32 palette_size = TexDecoder_GetPaletteSize(texformat);
 	bool texture_is_dynamic = false;
 	unsigned int texLevels;
 	PC_TexFormat pcfmt = PC_TEX_FMT_NONE;
@@ -204,37 +204,40 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	if (isPaletteTexture)
 		full_format = texformat | (tlutfmt << 16);
 
-	// hires texture loading and texture dumping require accurate hashes
-	if (g_ActiveConfig.bSafeTextureCache || g_ActiveConfig.bHiresTextures || g_ActiveConfig.bDumpTextures)
+	if (isPaletteTexture && (g_ActiveConfig.bSafeTextureCache || g_ActiveConfig.bHiresTextures || g_ActiveConfig.bDumpTextures))
 	{
-		texHash = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
+		const u32 palette_size = TexDecoder_GetPaletteSize(texformat);
+		tlut_hash = GetHash64(&texMem[tlutaddr], palette_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
+
+		// NOTE: For non-paletted textures, texID is equal to the texture address.
+		//		A paletted texture, however, may have multiple texIDs assigned though depending on the currently used tlut.
+		//		This (changing texID depending on the tlut_hash) is a trick to get around
+		//		an issue with Metroid Prime's fonts (it has multiple sets of fonts on each other
+		//		stored in a single texture and uses the palette to make different characters
+		//		visible or invisible. Thus, unless we want to recreate the textures for every drawn character,
+		//		we must make sure that a paletted texture gets assigned multiple IDs for each tlut used.
+		//
+		// TODO: Because texID isn't always the same as the address now, CopyRenderTargetToTexture might be broken now
+		if (g_ActiveConfig.bSafeTextureCache)
+			texID ^= ((u32)tlut_hash) ^(u32)(tlut_hash >> 32);
+	}
 
-		if (isPaletteTexture)
-		{
-			// WARNING! texID != address now => may break CopyRenderTargetToTexture (cf. TODO up)
-			// tlut size can be up to 32768B (GX_TF_C14X2) but Safer == Slower.
-			// This trick (to change the texID depending on the TLUT addr) is a trick to get around
-			// an issue with metroid prime's fonts, where it has multiple sets of fonts on top of
-			// each other stored in a single texture, and uses the palette to make different characters
-			// visible or invisible. Thus, unless we want to recreate the textures for every drawn character,
-			// we must make sure that texture with different tluts get different IDs.
 
-			const u64 tlutHash = GetHash64(texMem + tlutaddr, palette_size,
-				g_ActiveConfig.iSafeTextureCache_ColorSamples);
+	TCacheEntryBase *entry = textures[texID];
+	if (entry)
+	{
+		// hires texture loading and texture dumping require accurate hashes
+		if (g_ActiveConfig.bSafeTextureCache || g_ActiveConfig.bHiresTextures || g_ActiveConfig.bDumpTextures)
+		{
+			texHash = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
 
-			texHash ^= tlutHash;
+			if (isPaletteTexture)
+				texHash ^= tlut_hash;
 
 			if (g_ActiveConfig.bSafeTextureCache)
-				texID ^= ((u32)tlutHash) ^ (u32)(tlutHash >> 32);
+				hash_value = texHash;
 		}
 
-		if (g_ActiveConfig.bSafeTextureCache)
-			hash_value = texHash;
-	}
-
-	TCacheEntryBase *entry = textures[texID];
-	if (entry)
-	{
 		// 1. Adjust reference hash:
 		// safe texcache: reference hash was calculated above for normal textures. 0 for virtual EFB copies.
 		// unsafe texcache: 0 for virtual EFB copies. Safe hash for dynamic EFB copies. First pixel for normal textures.
@@ -254,7 +257,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 					hash_value = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
 
 					if (isPaletteTexture)
-						hash_value ^= GetHash64(&texMem[tlutaddr], palette_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
+						hash_value ^= tlut_hash; // TODO: Ugly, this is using Safe Texture Cache parameters in nonsafe TC
 			}
 		}
 
-- 
cgit v1.2.3


From 8c2d87f668ccc2f210bfbd379a04ced272a52d54 Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Mon, 26 Dec 2011 21:37:18 +0100
Subject: TextureCacheBase: Move around stuff, add some TODOs

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 25 +++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index 926b86b29a..e7df59275e 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -173,12 +173,9 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	u32 address, unsigned int width, unsigned int height, int texformat,
 	unsigned int tlutaddr, int tlutfmt, bool UseNativeMips, unsigned int maxlevel)
 {
-	// necessary?
 	if (0 == address)
 		return NULL;
 
-	u8* ptr = Memory::GetPointer(address);
-
 	// TexelSizeInNibbles(format)*width*height/16;
 	const unsigned int bsw = TexDecoder_GetBlockWidthInTexels(texformat) - 1;
 	const unsigned int bsh = TexDecoder_GetBlockHeightInTexels(texformat) - 1;
@@ -187,20 +184,17 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	unsigned int expandedHeight = (height + bsh) & (~bsh);
 	const unsigned int nativeW = width;
 	const unsigned int nativeH = height;
-	bool isPow2;
 
-	u64 hash_value = TEXHASH_INVALID;
-	u64 texHash = TEXHASH_INVALID;
-	u64 tlut_hash = TEXHASH_INVALID;
+	// TODO: Force STC enabled when using custom textures or when dumping textures. There's no need for having two different texture hashes then.
 	u32 texID = address;
+	u64 hash_value = TEXHASH_INVALID; // Hash assigned to texcache entry
+	u64 texHash = TEXHASH_INVALID; // Accurate hash used for texture dumping, hires texture lookup. Equal to hash_value with STC.
+	u64 tlut_hash = TEXHASH_INVALID;
+
 	u32 full_format = texformat;
-	const u32 texture_size = TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, texformat);
-	bool texture_is_dynamic = false;
-	unsigned int texLevels;
 	PC_TexFormat pcfmt = PC_TEX_FMT_NONE;
 
 	const bool isPaletteTexture = (texformat == GX_TF_C4 || texformat == GX_TF_C8 || texformat == GX_TF_C14X2);
-
 	if (isPaletteTexture)
 		full_format = texformat | (tlutfmt << 16);
 
@@ -223,6 +217,11 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	}
 
 
+	bool texture_is_dynamic = false;
+	const u32 texture_size = TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, texformat);
+
+	u8* ptr = Memory::GetPointer(address);
+
 	TCacheEntryBase *entry = textures[texID];
 	if (entry)
 	{
@@ -318,6 +317,8 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		pcfmt = TexDecoder_Decode(temp, ptr, expandedWidth,
 					expandedHeight, texformat, tlutaddr, tlutfmt, g_ActiveConfig.backend_info.bUseRGBATextures);
 
+	bool isPow2;
+	unsigned int texLevels;
 	UseNativeMips = UseNativeMips && (width == nativeW && height == nativeH); // Only load native mips if their dimensions fit to our virtual texture dimensions
 	isPow2 = !((width & (width - 1)) || (height & (height - 1)));
 	texLevels = (isPow2 && UseNativeMips && maxlevel) ?
@@ -333,6 +334,8 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		// Sometimes, we can get around recreating a texture if only the number of mip levels gets changes
 		// e.g. if our texture cache entry got too many mipmap levels we can limit the number of used levels by setting the appropriate render states
 		// Thus, we don't update this member for every Load, but just whenever the texture gets recreated
+		//
+		// TODO: Won't we end up recreating textures all the time because maxlevel doesn't necessarily equal texLevels?
 		entry->num_mipmaps = maxlevel; // TODO: Does this actually work? We can't really adjust mipmap settings per-stage...
 
 		GFX_DEBUGGER_PAUSE_AT(NEXT_NEW_TEXTURE, true);
-- 
cgit v1.2.3


From 5239ba88c99c5516b412aa3dc408a448b2bd7eba Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Mon, 26 Dec 2011 22:04:59 +0100
Subject: TextureCache: Remove unsafe texture cache

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 64 +++++-------------------
 1 file changed, 12 insertions(+), 52 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index e7df59275e..369712bede 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -23,28 +23,19 @@ enum
 
 TextureCache *g_texture_cache;
 
- GC_ALIGNED16(u8 *TextureCache::temp) = NULL;
+GC_ALIGNED16(u8 *TextureCache::temp) = NULL;
 
 TextureCache::TexCache TextureCache::textures;
 bool TextureCache::DeferredInvalidate;
 
 TextureCache::TCacheEntryBase::~TCacheEntryBase()
 {
-	if (0 == addr)
-		return;
-
-	if (!isRenderTarget && !g_ActiveConfig.bSafeTextureCache)
-	{
-		u32 *const ptr = (u32*)Memory::GetPointer(addr);
-		if (ptr && *ptr == hash)
-			*ptr = oldpixel;
-	}
 }
 
 TextureCache::TextureCache()
 {
 	if (!temp)
-		temp =(u8*) AllocateAlignedMemory(TEMP_SIZE,16);
+		temp = (u8*)AllocateAlignedMemory(TEMP_SIZE,16);
 	TexDecoder_SetTexFmtOverlayOptions(g_ActiveConfig.bTexFmtOverlayEnable, g_ActiveConfig.bTexFmtOverlayCenter);
     if(g_ActiveConfig.bHiresTextures && !g_ActiveConfig.bDumpTextures)
 		HiresTextures::Init(SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str());
@@ -198,7 +189,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	if (isPaletteTexture)
 		full_format = texformat | (tlutfmt << 16);
 
-	if (isPaletteTexture && (g_ActiveConfig.bSafeTextureCache || g_ActiveConfig.bHiresTextures || g_ActiveConfig.bDumpTextures))
+	if (isPaletteTexture)
 	{
 		const u32 palette_size = TexDecoder_GetPaletteSize(texformat);
 		tlut_hash = GetHash64(&texMem[tlutaddr], palette_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
@@ -212,8 +203,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		//		we must make sure that a paletted texture gets assigned multiple IDs for each tlut used.
 		//
 		// TODO: Because texID isn't always the same as the address now, CopyRenderTargetToTexture might be broken now
-		if (g_ActiveConfig.bSafeTextureCache)
-			texID ^= ((u32)tlut_hash) ^(u32)(tlut_hash >> 32);
+		texID ^= ((u32)tlut_hash) ^(u32)(tlut_hash >> 32);
 	}
 
 
@@ -225,40 +215,15 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	TCacheEntryBase *entry = textures[texID];
 	if (entry)
 	{
-		// hires texture loading and texture dumping require accurate hashes
-		if (g_ActiveConfig.bSafeTextureCache || g_ActiveConfig.bHiresTextures || g_ActiveConfig.bDumpTextures)
-		{
-			texHash = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
+		// 1. Calculate reference hash:
+		// calculated from RAM texture data for normal textures. Hashes for paletted textures are modified by tlut_hash. 0 for virtual EFB copies.
+		hash_value = texHash = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
 
-			if (isPaletteTexture)
-				texHash ^= tlut_hash;
+		if (isPaletteTexture)
+			hash_value = texHash ^= tlut_hash;
 
-			if (g_ActiveConfig.bSafeTextureCache)
-				hash_value = texHash;
-		}
-
-		// 1. Adjust reference hash:
-		// safe texcache: reference hash was calculated above for normal textures. 0 for virtual EFB copies.
-		// unsafe texcache: 0 for virtual EFB copies. Safe hash for dynamic EFB copies. First pixel for normal textures.
-		if (g_ActiveConfig.bSafeTextureCache)
-		{
-			if (g_ActiveConfig.bCopyEFBToTexture && (entry->isRenderTarget || entry->isDynamic))
-				hash_value = TEXHASH_INVALID;
-		}
-		else
-		{
-			if (!(entry->isRenderTarget || entry->isDynamic))
-				hash_value = *(u32*)ptr;
-			else if (g_ActiveConfig.bCopyEFBToTexture)
-				hash_value = TEXHASH_INVALID;
-			else
-			{
-					hash_value = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
-
-					if (isPaletteTexture)
-						hash_value ^= tlut_hash; // TODO: Ugly, this is using Safe Texture Cache parameters in nonsafe TC
-			}
-		}
+		if (g_ActiveConfig.bCopyEFBToTexture && (entry->isRenderTarget || entry->isDynamic))
+			hash_value = TEXHASH_INVALID;
 
 		// 2. a) For EFB copies, only the hash and the texture address need to match
 		if ((entry->isRenderTarget || entry->isDynamic) && hash_value == entry->hash && address == entry->addr)
@@ -344,12 +309,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	entry->SetGeneralParameters(address, texture_size, full_format, entry->num_mipmaps);
 	entry->SetDimensions(nativeW, nativeH, width, height);
 	entry->SetEFBCopyParameters(false, texture_is_dynamic);
-	entry->oldpixel = *(u32*)ptr;
-
-	if (g_ActiveConfig.bSafeTextureCache || entry->isDynamic)
-		entry->hash = hash_value;
-	else
-		entry->hash = *(u32*)ptr = (u32)(((double)rand() / RAND_MAX) * 0xFFFFFFFF);
+	entry->hash = hash_value;
 
 	// load texture
 	entry->Load(width, height, expandedWidth, 0, (texLevels == 0));
-- 
cgit v1.2.3


From 67129404dd8d6944ccc5ad1ae24ece33ae5c8bba Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Mon, 26 Dec 2011 23:14:12 +0100
Subject: TextureCacheBase: Small bugfix Added documentation for hybrid EFB
 copy stuff

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 48 +++++++++++++++++++-----
 1 file changed, 38 insertions(+), 10 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index 369712bede..7c78b6f937 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -189,6 +189,10 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	if (isPaletteTexture)
 		full_format = texformat | (tlutfmt << 16);
 
+	u8* ptr = Memory::GetPointer(address);
+	const u32 texture_size = TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, texformat);
+
+	hash_value = texHash = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
 	if (isPaletteTexture)
 	{
 		const u32 palette_size = TexDecoder_GetPaletteSize(texformat);
@@ -204,24 +208,15 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		//
 		// TODO: Because texID isn't always the same as the address now, CopyRenderTargetToTexture might be broken now
 		texID ^= ((u32)tlut_hash) ^(u32)(tlut_hash >> 32);
+		hash_value = texHash ^= tlut_hash;
 	}
 
-
 	bool texture_is_dynamic = false;
-	const u32 texture_size = TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, texformat);
-
-	u8* ptr = Memory::GetPointer(address);
-
 	TCacheEntryBase *entry = textures[texID];
 	if (entry)
 	{
 		// 1. Calculate reference hash:
 		// calculated from RAM texture data for normal textures. Hashes for paletted textures are modified by tlut_hash. 0 for virtual EFB copies.
-		hash_value = texHash = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
-
-		if (isPaletteTexture)
-			hash_value = texHash ^= tlut_hash;
-
 		if (g_ActiveConfig.bCopyEFBToTexture && (entry->isRenderTarget || entry->isDynamic))
 			hash_value = TEXHASH_INVALID;
 
@@ -378,6 +373,39 @@ return_entry:
 void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat, unsigned int srcFormat,
 	const EFBRectangle& srcRect, bool isIntensity, bool scaleByHalf)
 {
+	// 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:
+	//		1) Whenever this function gets called, encode the requested EFB data to RAM (like EFB to RAM)
+	//		2a) If we haven't copied to the specified dstAddr yet, copy the requested EFB data to a texture object in VRAM as well (like EFB to texture)
+	//			Create a texture cache entry for the render target (isRenderTarget = true, isDynamic = false)
+	//			Store a hash of the encoded RAM data in the texcache entry.
+	//		2b) If we already have created a texcache entry for dstAddr (i.e. if we copied to dstAddr before) AND isDynamic is false:
+	//			Do the same like above, but reuse the old texcache entry instead of creating a new one.
+	//		2c) If we already have created a texcache entry for dstAddr AND isDynamic is true (isRenderTarget will be false then)
+	//			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 end up deleting it and reloading the data from RAM again 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 isDynamic is still false, reuse the VRAM copy you created
+	//		3b) If the two hashes differ AND isDynamic is still false, screw your existing VRAM copy. Set isRenderTarget to false and isDynamic to true.
+	//			Redecode the source RAM data to a VRAM object. The entry basically behaves like a normal texture now.
+	//		3c) If isDynamic is true, treat the EFB copy like a normal texture.
+	//		Advantage: Neither as fast as EFB to texture nor as slow as EFB to RAM, so it's a good compromise.
+	//					Non-dynamic EFB copies can be visually enhanced like with EFB to texture.
+	//					Compatibility ideally is as good as with EFB to RAM.
+	//		Disadvantage: Depends on accurate texture hashing being enabled. However, with accurate hashing you end up being as slow as EFB to RAM anyway.
+	//
+	// Disadvantage of all methods: Calling this function requires the GPU to perform a pipeline flush which stalls any further CPU processing.
+
 	float colmat[28] = {0};
 	float *const fConstAdd = colmat + 16;
 	float *const ColorMask = colmat + 20;
-- 
cgit v1.2.3


From 3b38295cbd08c98e7654e8715a88f4456cd61de5 Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Tue, 27 Dec 2011 00:05:26 +0100
Subject: TextureCacheBase: De-uglify hybrid EFB copies (documentation needs
 updating though) TextureCacheBase: Fixed dynamic EFB copies being set to
 normal textures.

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 36 +++++++++---------------
 1 file changed, 14 insertions(+), 22 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index 7c78b6f937..9b4891b98e 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -157,7 +157,7 @@ void TextureCache::ClearRenderTargets()
 		iter = textures.begin(),
 		tcend = textures.end();
 	for (; iter!=tcend; ++iter)
-		iter->second->isRenderTarget = false;
+		iter->second->efbcopy_state = EC_NO_COPY;
 }
 
 TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
@@ -211,20 +211,18 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		hash_value = texHash ^= tlut_hash;
 	}
 
-	bool texture_is_dynamic = false;
 	TCacheEntryBase *entry = textures[texID];
 	if (entry)
 	{
 		// 1. Calculate reference hash:
 		// calculated from RAM texture data for normal textures. Hashes for paletted textures are modified by tlut_hash. 0 for virtual EFB copies.
-		if (g_ActiveConfig.bCopyEFBToTexture && (entry->isRenderTarget || entry->isDynamic))
+		if (g_ActiveConfig.bCopyEFBToTexture && entry->IsEfbCopy())
 			hash_value = TEXHASH_INVALID;
 
 		// 2. a) For EFB copies, only the hash and the texture address need to match
-		if ((entry->isRenderTarget || entry->isDynamic) && hash_value == entry->hash && address == entry->addr)
+		if (entry->IsEfbCopy() && hash_value == entry->hash && address == entry->addr)
 		{
 			// TODO: Print a warning if the format changes! In this case, we could reinterpret the internal texture object data to the new pixel format (similiar to what is already being done in Renderer::ReinterpretPixelFormat())
-			entry->isDynamic = false;
 			goto return_entry;
 		}
 
@@ -237,13 +235,11 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 
 		// 3. If we reach this line, we'll have to upload the new texture data to VRAM.
 		//    If we're lucky, the texture parameters didn't change and we can reuse the internal texture object instead of destroying and recreating it.
-		texture_is_dynamic = (entry->isRenderTarget || entry->isDynamic) && !g_ActiveConfig.bCopyEFBToTexture;
-
+		//
 		// TODO: Don't we need to force texture decoding to RGBA8 for dynamic EFB copies?
 		// TODO: Actually, it should be enough if the internal texture format matches...
-		if (!entry->isRenderTarget &&
-			((!entry->isDynamic && width == entry->native_width && height == entry->native_height && full_format == entry->format && entry->num_mipmaps == maxlevel)
-			|| (entry->isDynamic && entry->native_width == width && entry->native_height == height)))
+		if ((entry->efbcopy_state == EC_NO_COPY && width == entry->native_width && height == entry->native_height && full_format == entry->format && entry->num_mipmaps == maxlevel)
+			|| (entry->efbcopy_state == EC_VRAM_DYNAMIC && entry->native_width == width && entry->native_height == height))
 		{
 			// reuse the texture
 		}
@@ -297,14 +293,16 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		//
 		// TODO: Won't we end up recreating textures all the time because maxlevel doesn't necessarily equal texLevels?
 		entry->num_mipmaps = maxlevel; // TODO: Does this actually work? We can't really adjust mipmap settings per-stage...
+		entry->efbcopy_state = EC_NO_COPY;
 
 		GFX_DEBUGGER_PAUSE_AT(NEXT_NEW_TEXTURE, true);
 	}
 
 	entry->SetGeneralParameters(address, texture_size, full_format, entry->num_mipmaps);
 	entry->SetDimensions(nativeW, nativeH, width, height);
-	entry->SetEFBCopyParameters(false, texture_is_dynamic);
 	entry->hash = hash_value;
+	if (g_ActiveConfig.bCopyEFBToTexture) entry->efbcopy_state = EC_NO_COPY;
+	else if (entry->IsEfbCopy()) entry->efbcopy_state = EC_VRAM_DYNAMIC;
 
 	// load texture
 	entry->Load(width, height, expandedWidth, 0, (texLevels == 0));
@@ -608,15 +606,15 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 	unsigned int scaled_tex_w = g_ActiveConfig.bCopyEFBScaled ? Renderer::EFBToScaledX(tex_w) : tex_w;
 	unsigned int scaled_tex_h = g_ActiveConfig.bCopyEFBScaled ? Renderer::EFBToScaledY(tex_h) : tex_h;
 
-	bool texture_is_dynamic = false;
 
 	TCacheEntryBase *entry = textures[dstAddr];
 	if (entry)
 	{
-		if ((entry->isRenderTarget && entry->virtual_width == scaled_tex_w && entry->virtual_height == scaled_tex_h) 
-			|| (entry->isDynamic && entry->native_width == tex_w && entry->native_height == tex_h))
+		if ((entry->efbcopy_state == EC_VRAM_READY && entry->virtual_width == scaled_tex_w && entry->virtual_height == scaled_tex_h) 
+			|| (entry->efbcopy_state == EC_VRAM_DYNAMIC && entry->native_width == tex_w && entry->native_height == tex_h))
 		{
-			texture_is_dynamic = entry->isDynamic;
+			scaled_tex_w = tex_w;
+			scaled_tex_h = tex_h;
 		}
 		else
 		{
@@ -626,12 +624,6 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 		}
 	}
 
-	if (texture_is_dynamic)
-	{
-		scaled_tex_w = tex_w;
-		scaled_tex_h = tex_h;
-	}
-
 	if (NULL == entry)
 	{
 		// create the texture
@@ -640,8 +632,8 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 		// TODO: Using the wrong dstFormat, dumb...
 		entry->SetGeneralParameters(dstAddr, 0, dstFormat, 0);
 		entry->SetDimensions(tex_w, tex_h, scaled_tex_w, scaled_tex_h);
-		entry->SetEFBCopyParameters(true, false);
 		entry->SetHashes(TEXHASH_INVALID);
+		entry->efbcopy_state = EC_VRAM_READY;
 	}
 
 	entry->frameCount = frameCount;
-- 
cgit v1.2.3


From b34b6e47f20b055e3b35f28f04e99fc6de86415b Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@googlemail.com>
Date: Tue, 24 Jan 2012 15:25:01 +0100
Subject: TextureCacheBase: Remove a redundant variable

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index 9b4891b98e..6f2c9ebd0c 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -176,10 +176,8 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	const unsigned int nativeW = width;
 	const unsigned int nativeH = height;
 
-	// TODO: Force STC enabled when using custom textures or when dumping textures. There's no need for having two different texture hashes then.
 	u32 texID = address;
-	u64 hash_value = TEXHASH_INVALID; // Hash assigned to texcache entry
-	u64 texHash = TEXHASH_INVALID; // Accurate hash used for texture dumping, hires texture lookup. Equal to hash_value with STC.
+	u64 tex_hash = TEXHASH_INVALID; // Hash assigned to texcache entry (also used to generate filenames used for texture dumping and custom texture lookup)
 	u64 tlut_hash = TEXHASH_INVALID;
 
 	u32 full_format = texformat;
@@ -192,7 +190,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	u8* ptr = Memory::GetPointer(address);
 	const u32 texture_size = TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, texformat);
 
-	hash_value = texHash = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
+	tex_hash = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
 	if (isPaletteTexture)
 	{
 		const u32 palette_size = TexDecoder_GetPaletteSize(texformat);
@@ -208,7 +206,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		//
 		// TODO: Because texID isn't always the same as the address now, CopyRenderTargetToTexture might be broken now
 		texID ^= ((u32)tlut_hash) ^(u32)(tlut_hash >> 32);
-		hash_value = texHash ^= tlut_hash;
+		tex_hash ^= tlut_hash;
 	}
 
 	TCacheEntryBase *entry = textures[texID];
@@ -217,17 +215,17 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		// 1. Calculate reference hash:
 		// calculated from RAM texture data for normal textures. Hashes for paletted textures are modified by tlut_hash. 0 for virtual EFB copies.
 		if (g_ActiveConfig.bCopyEFBToTexture && entry->IsEfbCopy())
-			hash_value = TEXHASH_INVALID;
+			tex_hash = TEXHASH_INVALID;
 
 		// 2. a) For EFB copies, only the hash and the texture address need to match
-		if (entry->IsEfbCopy() && hash_value == entry->hash && address == entry->addr)
+		if (entry->IsEfbCopy() && tex_hash == entry->hash && address == entry->addr)
 		{
 			// TODO: Print a warning if the format changes! In this case, we could reinterpret the internal texture object data to the new pixel format (similiar to what is already being done in Renderer::ReinterpretPixelFormat())
 			goto return_entry;
 		}
 
 		// 2. b) For normal textures, all texture parameters need to match
-		if (address == entry->addr && hash_value == entry->hash && full_format == entry->format &&
+		if (address == entry->addr && tex_hash == entry->hash && full_format == entry->format &&
 			entry->num_mipmaps == maxlevel && entry->native_width == nativeW && entry->native_height == nativeH)
 		{
 			goto return_entry;
@@ -259,7 +257,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		unsigned int newWidth = width;
 		unsigned int newHeight = height;
 
-		sprintf(texPathTemp, "%s_%08x_%i", SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str(), (u32) (texHash & 0x00000000FFFFFFFFLL), texformat);
+		sprintf(texPathTemp, "%s_%08x_%i", SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str(), (u32) (tex_hash & 0x00000000FFFFFFFFLL), texformat);
 		pcfmt = HiresTextures::GetHiresTex(texPathTemp, &newWidth, &newHeight, texformat, temp);
 
 		if (pcfmt != PC_TEX_FMT_NONE)
@@ -300,7 +298,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 
 	entry->SetGeneralParameters(address, texture_size, full_format, entry->num_mipmaps);
 	entry->SetDimensions(nativeW, nativeH, width, height);
-	entry->hash = hash_value;
+	entry->hash = tex_hash;
 	if (g_ActiveConfig.bCopyEFBToTexture) entry->efbcopy_state = EC_NO_COPY;
 	else if (entry->IsEfbCopy()) entry->efbcopy_state = EC_VRAM_DYNAMIC;
 
@@ -349,7 +347,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 
 		sprintf(szTemp, "%s/%s_%08x_%i.png", szDir.c_str(),
 				SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str(),
-				(u32) (texHash & 0x00000000FFFFFFFFLL), texformat);
+				(u32) (tex_hash & 0x00000000FFFFFFFFLL), texformat);
 
 		if (false == File::Exists(szTemp))
 			entry->Save(szTemp);
-- 
cgit v1.2.3


From cf899781f980ecf7dbe373a36c78a2a302e3951d Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@googlemail.com>
Date: Tue, 24 Jan 2012 16:38:27 +0100
Subject: TextureCacheBase: Update and improve documentation for EFB copies

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 40 ++++++++++++++----------
 1 file changed, 23 insertions(+), 17 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index 6f2c9ebd0c..0a59aeefa4 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -377,30 +377,36 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 	//		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.
+	//		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:
-	//		1) Whenever this function gets called, encode the requested EFB data to RAM (like EFB to RAM)
-	//		2a) If we haven't copied to the specified dstAddr yet, copy the requested EFB data to a texture object in VRAM as well (like EFB to texture)
-	//			Create a texture cache entry for the render target (isRenderTarget = true, isDynamic = false)
-	//			Store a hash of the encoded RAM data in the texcache entry.
-	//		2b) If we already have created a texcache entry for dstAddr (i.e. if we copied to dstAddr before) AND isDynamic is false:
-	//			Do the same like above, but reuse the old texcache entry instead of creating a new one.
-	//		2c) If we already have created a texcache entry for dstAddr AND isDynamic is true (isRenderTarget will be false then)
-	//			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 end up deleting it and reloading the data from RAM again anyway.
+	//		1a) Whenever this function gets called, encode the requested EFB data to RAM (like EFB to RAM)
+	//		1b) Set efbcopy_state to EC_VRAM_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 (efbcopy_state = EC_VRAM_READY)
+	//			- Store a hash of the encoded RAM data in the texcache entry.
+	//		2b) Entry exists AND efbcopy_state is EC_VRAM_READY:
+	//			- Like case 2a, but reuse the old texcache entry instead of creating a new one.
+	//		2c) Entry exists AND efbcopy_state is EC_VRAM_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 isDynamic is still false, reuse the VRAM copy you created
-	//		3b) If the two hashes differ AND isDynamic is still false, screw your existing VRAM copy. Set isRenderTarget to false and isDynamic to true.
+	//		3a) If the two hashes match AND efbcopy_state is EC_VRAM_READY, reuse the VRAM copy you created
+	//		3b) If the two hashes differ AND efbcopy_state is EC_VRAM_READY, screw your existing VRAM copy. Set efbcopy_state to EC_VRAM_DYNAMIC.
 	//			Redecode the source RAM data to a VRAM object. The entry basically behaves like a normal texture now.
-	//		3c) If isDynamic is true, treat the EFB copy like a normal texture.
-	//		Advantage: Neither as fast as EFB to texture nor as slow as EFB to RAM, so it's a good compromise.
-	//					Non-dynamic EFB copies can be visually enhanced like with EFB to texture.
-	//					Compatibility ideally is as good as with EFB to RAM.
-	//		Disadvantage: Depends on accurate texture hashing being enabled. However, with accurate hashing you end up being as slow as EFB to RAM anyway.
+	//		3c) If efbcopy_state is EC_VRAM_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;
-- 
cgit v1.2.3


From 1446fb33d515fc300c33afd535b22f441544b86e Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@googlemail.com>
Date: Sun, 29 Jan 2012 20:24:23 +0100
Subject: TextureCacheBase: Replace the efbcopy_state member variable of
 texture cache entries with a more general "texture type"

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 32 ++++++++++++------------
 1 file changed, 16 insertions(+), 16 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index 0a59aeefa4..885116ae18 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -157,7 +157,7 @@ void TextureCache::ClearRenderTargets()
 		iter = textures.begin(),
 		tcend = textures.end();
 	for (; iter!=tcend; ++iter)
-		iter->second->efbcopy_state = EC_NO_COPY;
+		iter->second->type = TCET_AUTOFETCH;
 }
 
 TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
@@ -236,8 +236,8 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		//
 		// TODO: Don't we need to force texture decoding to RGBA8 for dynamic EFB copies?
 		// TODO: Actually, it should be enough if the internal texture format matches...
-		if ((entry->efbcopy_state == EC_NO_COPY && width == entry->native_width && height == entry->native_height && full_format == entry->format && entry->num_mipmaps == maxlevel)
-			|| (entry->efbcopy_state == EC_VRAM_DYNAMIC && entry->native_width == width && entry->native_height == height))
+		if ((entry->type == TCET_AUTOFETCH && width == entry->native_width && height == entry->native_height && full_format == entry->format && entry->num_mipmaps == maxlevel)
+			|| (entry->type == TCET_EC_DYNAMIC && entry->native_width == width && entry->native_height == height))
 		{
 			// reuse the texture
 		}
@@ -291,7 +291,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		//
 		// TODO: Won't we end up recreating textures all the time because maxlevel doesn't necessarily equal texLevels?
 		entry->num_mipmaps = maxlevel; // TODO: Does this actually work? We can't really adjust mipmap settings per-stage...
-		entry->efbcopy_state = EC_NO_COPY;
+		entry->type = TCET_AUTOFETCH;
 
 		GFX_DEBUGGER_PAUSE_AT(NEXT_NEW_TEXTURE, true);
 	}
@@ -299,8 +299,8 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	entry->SetGeneralParameters(address, texture_size, full_format, entry->num_mipmaps);
 	entry->SetDimensions(nativeW, nativeH, width, height);
 	entry->hash = tex_hash;
-	if (g_ActiveConfig.bCopyEFBToTexture) entry->efbcopy_state = EC_NO_COPY;
-	else if (entry->IsEfbCopy()) entry->efbcopy_state = EC_VRAM_DYNAMIC;
+	if (g_ActiveConfig.bCopyEFBToTexture) entry->type = TCET_AUTOFETCH;
+	else if (entry->IsEfbCopy()) entry->type = TCET_EC_DYNAMIC;
 
 	// load texture
 	entry->Load(width, height, expandedWidth, 0, (texLevels == 0));
@@ -382,23 +382,23 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 	//					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 efbcopy_state to EC_VRAM_DYNAMIC for all texture cache entries in the destination address range.
+	//		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 (efbcopy_state = EC_VRAM_READY)
+	//			- 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 efbcopy_state is EC_VRAM_READY:
+	//		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 efbcopy_state is EC_VRAM_DYNAMIC:
+	//		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 efbcopy_state is EC_VRAM_READY, reuse the VRAM copy you created
-	//		3b) If the two hashes differ AND efbcopy_state is EC_VRAM_READY, screw your existing VRAM copy. Set efbcopy_state to EC_VRAM_DYNAMIC.
+	//		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 efbcopy_state is EC_VRAM_DYNAMIC, treat the EFB copy like a normal texture.
+	//		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.
@@ -614,8 +614,8 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 	TCacheEntryBase *entry = textures[dstAddr];
 	if (entry)
 	{
-		if ((entry->efbcopy_state == EC_VRAM_READY && entry->virtual_width == scaled_tex_w && entry->virtual_height == scaled_tex_h) 
-			|| (entry->efbcopy_state == EC_VRAM_DYNAMIC && entry->native_width == tex_w && entry->native_height == tex_h))
+		if ((entry->type == TCET_EC_VRAM && entry->virtual_width == scaled_tex_w && entry->virtual_height == scaled_tex_h) 
+			|| (entry->type == TCET_EC_DYNAMIC && entry->native_width == tex_w && entry->native_height == tex_h))
 		{
 			scaled_tex_w = tex_w;
 			scaled_tex_h = tex_h;
@@ -637,7 +637,7 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 		entry->SetGeneralParameters(dstAddr, 0, dstFormat, 0);
 		entry->SetDimensions(tex_w, tex_h, scaled_tex_w, scaled_tex_h);
 		entry->SetHashes(TEXHASH_INVALID);
-		entry->efbcopy_state = EC_VRAM_READY;
+		entry->type = TCET_EC_VRAM;
 	}
 
 	entry->frameCount = frameCount;
-- 
cgit v1.2.3


From d1605abfa98c39de0e9b9e57944f9dc864c03b42 Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@googlemail.com>
Date: Sun, 29 Jan 2012 21:55:07 +0100
Subject: Add license header for TextureCacheBase files

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index 885116ae18..f37e4b2dd5 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -1,3 +1,19 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
 
 #include "MemoryUtil.h"
 
-- 
cgit v1.2.3


From eb01a110c9573ae0e822eefd3cc8c58d92774588 Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@googlemail.com>
Date: Sun, 29 Jan 2012 21:49:50 +0100
Subject: Implement texture preloading

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 42 ++++++++++++++++--------
 1 file changed, 28 insertions(+), 14 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index f37e4b2dd5..7873d1474e 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -173,12 +173,12 @@ void TextureCache::ClearRenderTargets()
 		iter = textures.begin(),
 		tcend = textures.end();
 	for (; iter!=tcend; ++iter)
-		iter->second->type = TCET_AUTOFETCH;
+		iter->second->type = TCET_NORMAL;
 }
 
 TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	u32 address, unsigned int width, unsigned int height, int texformat,
-	unsigned int tlutaddr, int tlutfmt, bool UseNativeMips, unsigned int maxlevel)
+	unsigned int tlutaddr, int tlutfmt, bool UseNativeMips, unsigned int maxlevel, bool from_tmem)
 {
 	if (0 == address)
 		return NULL;
@@ -203,10 +203,12 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	if (isPaletteTexture)
 		full_format = texformat | (tlutfmt << 16);
 
-	u8* ptr = Memory::GetPointer(address);
 	const u32 texture_size = TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, texformat);
+	u8* src_data;
+	if (from_tmem) src_data = &texMem[bpmem.tex[stage/4].texImage1[stage%4].tmem_even * TMEM_LINE_SIZE];
+	else src_data = Memory::GetPointer(address);
 
-	tex_hash = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
+	tex_hash = GetHash64(src_data, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
 	if (isPaletteTexture)
 	{
 		const u32 palette_size = TexDecoder_GetPaletteSize(texformat);
@@ -225,7 +227,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		tex_hash ^= tlut_hash;
 	}
 
-	TCacheEntryBase *entry = textures[texID];
+	TCacheEntryBase *entry = textures[texID]; // TODO: Should use a different texID for preloaded textures!
 	if (entry)
 	{
 		// 1. Calculate reference hash:
@@ -252,7 +254,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		//
 		// TODO: Don't we need to force texture decoding to RGBA8 for dynamic EFB copies?
 		// TODO: Actually, it should be enough if the internal texture format matches...
-		if ((entry->type == TCET_AUTOFETCH && width == entry->native_width && height == entry->native_height && full_format == entry->format && entry->num_mipmaps == maxlevel)
+		if ((entry->type == TCET_NORMAL && width == entry->native_width && height == entry->native_height && full_format == entry->format && entry->num_mipmaps == maxlevel)
 			|| (entry->type == TCET_EC_DYNAMIC && entry->native_width == width && entry->native_height == height))
 		{
 			// reuse the texture
@@ -283,8 +285,9 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		}
 	}
 
+	// TODO: RGBA8 textures are stored non-continuously in tmem, that might cause problems when preloading is enabled
 	if (pcfmt == PC_TEX_FMT_NONE)
-		pcfmt = TexDecoder_Decode(temp, ptr, expandedWidth,
+		pcfmt = TexDecoder_Decode(temp, src_data, expandedWidth,
 					expandedHeight, texformat, tlutaddr, tlutfmt, g_ActiveConfig.backend_info.bUseRGBATextures);
 
 	bool isPow2;
@@ -301,13 +304,13 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	if (NULL == entry) {
 		textures[texID] = entry = g_texture_cache->CreateTexture(width, height, expandedWidth, texLevels, pcfmt);
 
-		// Sometimes, we can get around recreating a texture if only the number of mip levels gets changes
+		// Sometimes, we can get around recreating a texture if only the number of mip levels changes
 		// e.g. if our texture cache entry got too many mipmap levels we can limit the number of used levels by setting the appropriate render states
 		// Thus, we don't update this member for every Load, but just whenever the texture gets recreated
 		//
 		// TODO: Won't we end up recreating textures all the time because maxlevel doesn't necessarily equal texLevels?
 		entry->num_mipmaps = maxlevel; // TODO: Does this actually work? We can't really adjust mipmap settings per-stage...
-		entry->type = TCET_AUTOFETCH;
+		entry->type = TCET_NORMAL;
 
 		GFX_DEBUGGER_PAUSE_AT(NEXT_NEW_TEXTURE, true);
 	}
@@ -315,13 +318,13 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	entry->SetGeneralParameters(address, texture_size, full_format, entry->num_mipmaps);
 	entry->SetDimensions(nativeW, nativeH, width, height);
 	entry->hash = tex_hash;
-	if (g_ActiveConfig.bCopyEFBToTexture) entry->type = TCET_AUTOFETCH;
+	if (g_ActiveConfig.bCopyEFBToTexture) entry->type = TCET_NORMAL;
 	else if (entry->IsEfbCopy()) entry->type = TCET_EC_DYNAMIC;
 
 	// load texture
 	entry->Load(width, height, expandedWidth, 0, (texLevels == 0));
 
-	// load mips
+	// load mips - TODO: Loading mipmaps from tmem is untested!
 	if (texLevels > 1 && pcfmt != PC_TEX_FMT_NONE)
 	{
 		const unsigned int bsdepth = TexDecoder_GetTexelSizeInNibbles(texformat);
@@ -329,20 +332,31 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		unsigned int level = 1;
 		unsigned int mipWidth = (width + 1) >> 1;
 		unsigned int mipHeight = (height + 1) >> 1;
-		ptr += texture_size;
+
+		u8* ptr_even = NULL, *ptr_odd = NULL;
+		if (from_tmem)
+		{
+			ptr_even = &texMem[bpmem.tex[stage/4].texImage1[stage%4].tmem_even * TMEM_LINE_SIZE + texture_size];
+			ptr_odd = &texMem[bpmem.tex[stage/4].texImage2[stage%4].tmem_odd * TMEM_LINE_SIZE];
+		}
+		src_data += texture_size;
 
 		while ((mipHeight || mipWidth) && (level < texLevels))
 		{
+			u8** ptr;
+			if (from_tmem) ptr = (level % 2) ? &ptr_odd : &ptr_even;
+			else ptr = &src_data;
+
 			const unsigned int currentWidth = (mipWidth > 0) ? mipWidth : 1;
 			const unsigned int currentHeight = (mipHeight > 0) ? mipHeight : 1;
 
 			expandedWidth  = (currentWidth + bsw)  & (~bsw);
 			expandedHeight = (currentHeight + bsh) & (~bsh);
 
-			TexDecoder_Decode(temp, ptr, expandedWidth, expandedHeight, texformat, tlutaddr, tlutfmt, g_ActiveConfig.backend_info.bUseRGBATextures);
+			TexDecoder_Decode(temp, *ptr, expandedWidth, expandedHeight, texformat, tlutaddr, tlutfmt, g_ActiveConfig.backend_info.bUseRGBATextures);
 			entry->Load(currentWidth, currentHeight, expandedWidth, level, false);
 
-			ptr += ((std::max(mipWidth, bsw) * std::max(mipHeight, bsh) * bsdepth) >> 1);
+			*ptr += ((std::max(mipWidth, bsw) * std::max(mipHeight, bsh) * bsdepth) >> 1);
 			mipWidth >>= 1;
 			mipHeight >>= 1;
 			++level;
-- 
cgit v1.2.3


From 439613b83352d59ebaff25d35151e25f616804b4 Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Sat, 4 Feb 2012 13:01:52 +0100
Subject: TextureCacheBase: Remove a superfluous TODO (texture hashing takes
 care of that stuff)

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index 7873d1474e..cc14499330 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -227,7 +227,7 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		tex_hash ^= tlut_hash;
 	}
 
-	TCacheEntryBase *entry = textures[texID]; // TODO: Should use a different texID for preloaded textures!
+	TCacheEntryBase *entry = textures[texID];
 	if (entry)
 	{
 		// 1. Calculate reference hash:
-- 
cgit v1.2.3


From 6202714efdf66987e57846d3297a5972c8b75c38 Mon Sep 17 00:00:00 2001
From: NeoBrainX <NeoBrainX@gmail.com>
Date: Tue, 20 Mar 2012 22:36:21 +0100
Subject: Fix some regressions from r3b38295cbd08.

---
 Source/Core/VideoCommon/Src/TextureCacheBase.cpp | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

(limited to 'Source/Core/VideoCommon/Src/TextureCacheBase.cpp')

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index cc14499330..00ff9610be 100644
--- a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
+++ b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
@@ -172,8 +172,10 @@ void TextureCache::ClearRenderTargets()
 	TexCache::iterator
 		iter = textures.begin(),
 		tcend = textures.end();
+
 	for (; iter!=tcend; ++iter)
-		iter->second->type = TCET_NORMAL;
+		if (iter->second->type != TCET_EC_DYNAMIC)
+			iter->second->type = TCET_NORMAL;
 }
 
 TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
@@ -238,6 +240,9 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 		// 2. a) For EFB copies, only the hash and the texture address need to match
 		if (entry->IsEfbCopy() && tex_hash == entry->hash && address == entry->addr)
 		{
+			if (entry->type != TCET_EC_VRAM)
+				entry->type = TCET_NORMAL;
+
 			// TODO: Print a warning if the format changes! In this case, we could reinterpret the internal texture object data to the new pixel format (similiar to what is already being done in Renderer::ReinterpretPixelFormat())
 			goto return_entry;
 		}
@@ -318,8 +323,8 @@ TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int stage,
 	entry->SetGeneralParameters(address, texture_size, full_format, entry->num_mipmaps);
 	entry->SetDimensions(nativeW, nativeH, width, height);
 	entry->hash = tex_hash;
-	if (g_ActiveConfig.bCopyEFBToTexture) entry->type = TCET_NORMAL;
-	else if (entry->IsEfbCopy()) entry->type = TCET_EC_DYNAMIC;
+	if (entry->IsEfbCopy() && !g_ActiveConfig.bCopyEFBToTexture) entry->type = TCET_EC_DYNAMIC;
+	else entry->type = TCET_NORMAL;
 
 	// load texture
 	entry->Load(width, height, expandedWidth, 0, (texLevels == 0));
@@ -647,8 +652,11 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 		if ((entry->type == TCET_EC_VRAM && entry->virtual_width == scaled_tex_w && entry->virtual_height == scaled_tex_h) 
 			|| (entry->type == TCET_EC_DYNAMIC && entry->native_width == tex_w && entry->native_height == tex_h))
 		{
-			scaled_tex_w = tex_w;
-			scaled_tex_h = tex_h;
+			if (entry->type == TCET_EC_DYNAMIC)
+			{
+				scaled_tex_w = tex_w;
+				scaled_tex_h = tex_h;
+			}
 		}
 		else
 		{
-- 
cgit v1.2.3