Rebase immediate-removal on master

1 files changed, 329 insertions, 214 deletions

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index d3b7ca14ba..a5c390df3d 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"
 
@@ -17,68 +33,48 @@ extern int frameCount;
 
 enum
 {
-	TEMP_SIZE = (2048 * 2048 * 4),
 	TEXTURE_KILL_THRESHOLD = 200,
 };
 
 TextureCache *g_texture_cache;
 
- GC_ALIGNED16(u8 *TextureCache::temp) = NULL;
+GC_ALIGNED16(u8 *TextureCache::temp) = NULL;
+unsigned int TextureCache::temp_size;
 
 TextureCache::TexCache TextureCache::textures;
-bool TextureCache::DeferredInvalidate;
+
+TextureCache::BackupConfig TextureCache::backup_config;
+
 
 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()
 {
+	temp_size = 2048 * 2048 * 4;
 	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());
 	SetHash64Function(g_ActiveConfig.bHiresTextures || g_ActiveConfig.bDumpTextures);
 }
 
-void TextureCache::Invalidate(bool shutdown)
+void TextureCache::Invalidate()
 {
 	TexCache::iterator
 		iter = textures.begin(),
 		tcend = textures.end();
 	for (; iter != tcend; ++iter)
-	{
-		if (shutdown)
-			iter->second->addr = 0;
 		delete iter->second;
-	}
 
 	textures.clear();
-	if(g_ActiveConfig.bHiresTextures && !g_ActiveConfig.bDumpTextures)
-		HiresTextures::Init(SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str());
-	SetHash64Function(g_ActiveConfig.bHiresTextures || g_ActiveConfig.bDumpTextures);
-	
-	DeferredInvalidate = false;
-}
-
-void TextureCache::InvalidateDefer()
-{
-	DeferredInvalidate = true;
 }
 
 TextureCache::~TextureCache()
 {
-	Invalidate(true);
+	Invalidate();
 	if (temp)
 	{
 		FreeAlignedMemory(temp);
@@ -86,14 +82,55 @@ TextureCache::~TextureCache()
 	}
 }
 
+void TextureCache::OnConfigChanged(VideoConfig& config)
+{
+	if (!g_texture_cache)
+		goto skip_checks;
+
+	// TODO: Invalidating texcache is really stupid in some of these cases
+	if (config.iSafeTextureCache_ColorSamples != backup_config.s_colorsamples ||
+		config.bTexFmtOverlayEnable != backup_config.s_texfmt_overlay ||
+		config.bTexFmtOverlayCenter != backup_config.s_texfmt_overlay_center ||
+		config.bHiresTextures != backup_config.s_hires_textures)
+	{
+		g_texture_cache->Invalidate();
+
+		if(g_ActiveConfig.bHiresTextures)
+			HiresTextures::Init(SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str());
+
+		SetHash64Function(g_ActiveConfig.bHiresTextures || g_ActiveConfig.bDumpTextures);
+		TexDecoder_SetTexFmtOverlayOptions(g_ActiveConfig.bTexFmtOverlayEnable, g_ActiveConfig.bTexFmtOverlayCenter);
+	}
+
+	// TODO: Probably shouldn't clear all render targets here, just mark them dirty or something.
+	if (config.bEFBCopyCacheEnable != backup_config.s_copy_cache_enable || // TODO: not sure if this is needed?
+		config.bCopyEFBToTexture != backup_config.s_copy_efb_to_texture ||
+		config.bCopyEFBScaled != backup_config.s_copy_efb_scaled ||
+		config.bEFBCopyEnable != backup_config.s_copy_efb ||
+		config.iEFBScale != backup_config.s_efb_scale)
+	{
+		g_texture_cache->ClearRenderTargets();
+	}
+
+skip_checks:
+	backup_config.s_colorsamples = config.iSafeTextureCache_ColorSamples;
+	backup_config.s_copy_efb_to_texture = config.bCopyEFBToTexture;
+	backup_config.s_copy_efb_scaled = config.bCopyEFBScaled;
+	backup_config.s_copy_efb = config.bEFBCopyEnable;
+	backup_config.s_efb_scale = config.iEFBScale;
+	backup_config.s_texfmt_overlay = config.bTexFmtOverlayEnable;
+	backup_config.s_texfmt_overlay_center = config.bTexFmtOverlayCenter;
+	backup_config.s_hires_textures = config.bHiresTextures;
+	backup_config.s_copy_cache_enable = config.bEFBCopyCacheEnable;
+}
+
 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)
+		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++);
@@ -135,7 +172,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);
 		}
 	}
 }
@@ -166,20 +203,101 @@ void TextureCache::ClearRenderTargets()
 	TexCache::iterator
 		iter = textures.begin(),
 		tcend = textures.end();
+
 	for (; iter!=tcend; ++iter)
-		iter->second->isRenderTarget = false;
+		if (iter->second->type != TCET_EC_DYNAMIC)
+			iter->second->type = TCET_NORMAL;
+}
+
+bool TextureCache::CheckForCustomTextureLODs(u64 tex_hash, int texformat, unsigned int levels)
+{
+	// Just checking if the necessary files exist, if they can't be loaded or have incorrect dimensions LODs will be black
+	char texBasePathTemp[MAX_PATH];
+	char texPathTemp[MAX_PATH];
+
+	sprintf(texBasePathTemp, "%s_%08x_%i", SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str(), (u32) (tex_hash & 0x00000000FFFFFFFFLL), texformat);
+
+	for (unsigned int level = 1; level < levels; ++level)
+	{
+		sprintf(texPathTemp, "%s_mip%i", texBasePathTemp, level);
+		if (!HiresTextures::HiresTexExists(texPathTemp))
+		{
+			if (level > 1)
+				WARN_LOG(VIDEO, "Couldn't find custom texture LOD with index %i (filename: %s), disabling custom LODs for this texture", level, texPathTemp);
+
+			return false;
+		}
+	}
+	return true;
+}
+
+PC_TexFormat TextureCache::LoadCustomTexture(u64 tex_hash, int texformat, unsigned int level, unsigned int& width, unsigned int& height)
+{
+	char texPathTemp[MAX_PATH];
+	unsigned int newWidth = 0;
+	unsigned int newHeight = 0;
+
+	if (level == 0)
+		sprintf(texPathTemp, "%s_%08x_%i", SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str(), (u32) (tex_hash & 0x00000000FFFFFFFFLL), texformat);
+	else
+		sprintf(texPathTemp, "%s_%08x_%i_mip%i", SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str(), (u32) (tex_hash & 0x00000000FFFFFFFFLL), texformat, level);
+
+	unsigned int required_size = 0;
+	PC_TexFormat ret = HiresTextures::GetHiresTex(texPathTemp, &newWidth, &newHeight, &required_size, texformat, temp_size, temp);
+	if (ret == PC_TEX_FMT_NONE && temp_size < required_size)
+	{
+		// Allocate more memory and try again
+		// TODO: Should probably check if newWidth and newHeight are texture dimensions which are actually supported by the current video backend
+		temp_size = required_size;
+		FreeAlignedMemory(temp);
+		temp = (u8*)AllocateAlignedMemory(temp_size, 16);
+		ret = HiresTextures::GetHiresTex(texPathTemp, &newWidth, &newHeight, &required_size, texformat, temp_size, temp);
+	}
+
+	if (ret != PC_TEX_FMT_NONE)
+	{
+		width = newWidth;
+		height = newHeight;
+	}
+	return ret;
+}
+
+void TextureCache::DumpTexture(TCacheEntryBase* entry, unsigned int level)
+{
+	char szTemp[MAX_PATH];
+	std::string szDir = File::GetUserPath(D_DUMPTEXTURES_IDX) +
+		SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID;
+
+	// make sure that the directory exists
+	if (false == File::Exists(szDir) || false == File::IsDirectory(szDir))
+		File::CreateDir(szDir.c_str());
+
+	// For compatibility with old texture packs, don't print the LOD index for level 0.
+	 // TODO: TLUT format should actually be stored in filename? :/
+	if (level == 0)
+	{
+		sprintf(szTemp, "%s/%s_%08x_%i.png", szDir.c_str(),
+				SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str(),
+				(u32) (entry->hash & 0x00000000FFFFFFFFLL), entry->format & 0xFFFF);
+	}
+	else
+	{
+		sprintf(szTemp, "%s/%s_%08x_%i_mip%i.png", szDir.c_str(),
+				SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str(),
+				(u32) (entry->hash & 0x00000000FFFFFFFFLL), entry->format & 0xFFFF, level);
+	}
+
+	if (false == File::Exists(szTemp))
+		entry->Save(szTemp, level);
 }
 
 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)
 {
-	// 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;
@@ -188,226 +306,200 @@ 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 = 0;
-	u64 texHash = 0;
+	bool using_custom_texture = false;
+	bool using_custom_lods = false;
+
 	u32 texID = address;
+	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;
-	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;
 
 	const bool isPaletteTexture = (texformat == GX_TF_C4 || texformat == GX_TF_C8 || texformat == GX_TF_C14X2);
-
 	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)
-	{
-		texHash = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
-
-		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);
-
-			texHash ^= tlutHash;
-
-			if (g_ActiveConfig.bSafeTextureCache)
-				texID ^= ((u32)tlutHash) ^ (u32)(tlutHash >> 32);
-		}
+	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);
 
-		if (g_ActiveConfig.bSafeTextureCache)
-			hash_value = texHash;
+	tex_hash = GetHash64(src_data, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
+	if (isPaletteTexture)
+	{
+		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
+		texID ^= ((u32)tlut_hash) ^(u32)(tlut_hash >> 32);
+		tex_hash ^= tlut_hash;
 	}
 
 	TCacheEntryBase *entry = textures[texID];
 	if (entry)
 	{
-		if (!g_ActiveConfig.bSafeTextureCache)
+		// 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())
+			tex_hash = TEXHASH_INVALID;
+
+		// 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->isRenderTarget || entry->isDynamic)
-			{
-				if (!g_ActiveConfig.bCopyEFBToTexture)
-				{
-					hash_value = GetHash64(ptr, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
+			entry->type = TCET_EC_VRAM;
 
-					if (isPaletteTexture)
-					{
-						hash_value ^= GetHash64(&texMem[tlutaddr], palette_size,
-							g_ActiveConfig.iSafeTextureCache_ColorSamples);
-					}
-				}
-				else
-				{
-					hash_value = 0;
-				}
-			}
-			else
-			{
-				hash_value = *(u32*)ptr;
-			}
+			// 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;
 		}
-		else if ((entry->isRenderTarget || entry->isDynamic) && g_ActiveConfig.bCopyEFBToTexture)
+
+		// 2. b) For normal textures, all texture parameters need to match
+		if (address == entry->addr && tex_hash == entry->hash && full_format == entry->format &&
+			entry->num_mipmaps == maxlevel && entry->native_width == nativeW && entry->native_height == nativeH)
 		{
-			hash_value = 0;
+			goto return_entry;
 		}
 
-		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))
+		// 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.
+		//
+		// 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_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))
 		{
-			entry->isDynamic = false;
-			goto return_entry;
+			// 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->realW && height == entry->realH && full_format == entry->format && entry->mipLevels == maxlevel)
-				|| (entry->isDynamic && entry->realW == width && entry->realH == 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;
 		}
 	}
-	
-	if (g_ActiveConfig.bHiresTextures)
-	{
-		// Load Custom textures
-		char texPathTemp[MAX_PATH];
-
-		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);
-		pcfmt = HiresTextures::GetHiresTex(texPathTemp, &newWidth, &newHeight, texformat, temp);
 
+	if (g_ActiveConfig.bHiresTextures)
+	{
+		pcfmt = LoadCustomTexture(tex_hash, texformat, 0, width, height);
 		if (pcfmt != PC_TEX_FMT_NONE)
 		{
-			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
+			expandedWidth = width;
+			expandedHeight = height;
+			using_custom_texture = true;
 		}
 	}
 
+	// 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,
-			expandedHeight, texformat, tlutaddr, tlutfmt, g_ActiveConfig.backend_info.bUseRGBATextures);
+		pcfmt = TexDecoder_Decode(temp, src_data, expandedWidth,
+					expandedHeight, texformat, tlutaddr, tlutfmt, g_ActiveConfig.backend_info.bUseRGBATextures);
 
+	// TODO: Cleanup. Plus, we still autogenerate mipmaps in certain cases (we shouldn't do that)
+	bool isPow2;
+	unsigned int texLevels;
 	isPow2 = !((width & (width - 1)) || (height & (height - 1)));
-	texLevels = (isPow2 && UseNativeMips && maxlevel) ?
-		GetPow2(std::max(width, height)) : !isPow2;
-
-	if ((texLevels > (maxlevel + 1)) && maxlevel)
-		texLevels = maxlevel + 1;
+	texLevels = (isPow2 && maxlevel) ? GetPow2(std::max(width, height)) : !isPow2;
+	texLevels = maxlevel ? std::min(texLevels, maxlevel + 1) : texLevels;
+	using_custom_lods = using_custom_texture && CheckForCustomTextureLODs(tex_hash, texformat, texLevels);
+	UseNativeMips = UseNativeMips && !using_custom_lods && (width == nativeW && height == nativeH); // Only load native mips if their dimensions fit to our virtual texture dimensions
+	texLevels = (UseNativeMips || using_custom_lods) ? texLevels : !isPow2;
 
 	// create the entry/texture
 	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
-		entry->mipLevels = maxlevel;
+		//
+		// 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_NORMAL;
 
 		GFX_DEBUGGER_PAUSE_AT(NEXT_NEW_TEXTURE, true);
 	}
 
-	entry->addr = address;
-	entry->format = full_format;
-	entry->size_in_bytes = texture_size;
-
-	entry->virtualW = width;
-	entry->virtualH = height;
-
-	entry->realW = nativeW;
-	entry->realH = nativeH;
-		
-	entry->isRenderTarget = false;
-	entry->isNonPow2 = false;
-	entry->isDynamic = 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);
+	entry->SetGeneralParameters(address, texture_size, full_format, entry->num_mipmaps);
+	entry->SetDimensions(nativeW, nativeH, width, height);
+	entry->hash = tex_hash;
+	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));
 
-	// load mips
-	if (texLevels > 1 && pcfmt != PC_TEX_FMT_NONE)
+	if (g_ActiveConfig.bDumpTextures && !using_custom_texture)
+		DumpTexture(entry, 0);
+
+	// load mips - TODO: Loading mipmaps from tmem is untested!
+	if (texLevels > 1 && pcfmt != PC_TEX_FMT_NONE && UseNativeMips)
 	{
 		const unsigned int bsdepth = TexDecoder_GetTexelSizeInNibbles(texformat);
 
 		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);
-			entry->Load(currentWidth, currentHeight, expandedWidth, level);
+			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);
+			if (g_ActiveConfig.bDumpTextures)
+				DumpTexture(entry, level);
+
+			*ptr += ((std::max(mipWidth, bsw) * std::max(mipHeight, bsh) * bsdepth) >> 1);
 			mipWidth >>= 1;
 			mipHeight >>= 1;
 			++level;
 		}
 	}
-
-	// TODO: won't this cause loaded hires textures to be dumped as well?
-	// dump texture to file
-	if (g_ActiveConfig.bDumpTextures)
+	else if (texLevels > 1 && pcfmt != PC_TEX_FMT_NONE && using_custom_lods)
 	{
-		char szTemp[MAX_PATH];
-		std::string szDir = File::GetUserPath(D_DUMPTEXTURES_IDX) +
-			SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID;
+		unsigned int level = 1;
+		unsigned int mipWidth = (width + 1) >> 1;
+		unsigned int mipHeight = (height + 1) >> 1;
 
-		// make sure that the directory exists
-		if (false == File::Exists(szDir) || false == File::IsDirectory(szDir))
-			File::CreateDir(szDir.c_str());
+		while ((mipHeight || mipWidth) && (level < texLevels))
+		{
+			unsigned int currentWidth = (mipWidth > 0) ? mipWidth : 1;
+			unsigned int currentHeight = (mipHeight > 0) ? mipHeight : 1;
 
-		sprintf(szTemp, "%s/%s_%08x_%i.png", szDir.c_str(),
-				SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str(),
-				(u32) (texHash & 0x00000000FFFFFFFFLL), texformat);
+			LoadCustomTexture(tex_hash, texformat, level, currentWidth, currentHeight);
+			entry->Load(currentWidth, currentHeight, currentWidth, level, false);
 
-		if (false == File::Exists(szTemp))
-			entry->Save(szTemp);
+			mipWidth >>= 1;
+			mipHeight >>= 1;
+			++level;
+		}
 	}
 
 	INCSTAT(stats.numTexturesCreated);
@@ -426,10 +518,49 @@ 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:
+	//		1a) Whenever this function gets called, encode the requested EFB data to RAM (like EFB to RAM)
+	//		1b) Set type to TCET_EC_DYNAMIC for all texture cache entries in the destination address range.
+	//			If EFB copy caching is enabled, further checks will (try to) prevent redundant EFB copies.
+	//		2) Check if a texture cache entry for the specified dstAddr already exists (i.e. if an EFB copy was triggered to that address before):
+	//		2a) Entry doesn't exist:
+	//			- Also copy the requested EFB data to a texture object in VRAM (like EFB to texture)
+	//			- Create a texture cache entry for the target (type = TCET_EC_VRAM)
+	//			- Store a hash of the encoded RAM data in the texcache entry.
+	//		2b) Entry exists AND type is TCET_EC_VRAM:
+	//			- Like case 2a, but reuse the old texcache entry instead of creating a new one.
+	//		2c) Entry exists AND type is TCET_EC_DYNAMIC:
+	//			- Only encode the texture to RAM (like EFB to RAM) and store a hash of the encoded data in the existing texcache entry.
+	//			- Do NOT copy the requested EFB data to a VRAM object. Reason: the texture is dynamic, i.e. the CPU is modifying it. Storing a VRAM copy is useless, because we'd always end up deleting it and reloading the data from RAM anyway.
+	//		3) If the EFB copy gets used as a texture, compare the source RAM hash with the hash you stored when encoding the EFB data to RAM.
+	//		3a) If the two hashes match AND type is TCET_EC_VRAM, reuse the VRAM copy you created
+	//		3b) If the two hashes differ AND type is TCET_EC_VRAM, screw your existing VRAM copy. Set type to TCET_EC_DYNAMIC.
+	//			Redecode the source RAM data to a VRAM object. The entry basically behaves like a normal texture now.
+	//		3c) If type is TCET_EC_DYNAMIC, treat the EFB copy like a normal texture.
+	//		Advantage: 	Non-dynamic EFB copies can be visually enhanced like with EFB to texture.
+	//					Compatibility is as good as EFB to RAM.
+	//		Disadvantage:	Slower than EFB to texture and often even slower than EFB to RAM.
+	//						EFB copy cache depends on accurate texture hashing being enabled. However, with accurate hashing you end up being as slow as without a copy cache anyway.
+	//
+	// Disadvantage of all methods: Calling this function requires the GPU to perform a pipeline flush which stalls any further CPU processing.
+	//
+	// For historical reasons, Dolphin doesn't actually implement "pure" EFB to RAM emulation, but only EFB to texture and hybrid EFB copies.
+
 	float colmat[28] = {0};
 	float *const fConstAdd = colmat + 16;
 	float *const ColorMask = colmat + 20;
-	ColorMask[0] = ColorMask[1] = ColorMask[2] = ColorMask[3] = 255.0f; 
+	ColorMask[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 +568,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 +578,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 +603,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 +616,6 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 			cbufid = 7;
 			break;
 		}
-		
 	}
 	else if (isIntensity) 
 	{
@@ -627,17 +759,16 @@ 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->virtualW == scaled_tex_w && entry->virtualH == scaled_tex_h) 
-			|| (entry->isDynamic && entry->realW == tex_w && entry->realH == tex_h))
+		if (entry->type == TCET_EC_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
+		else if (!(entry->type == TCET_EC_VRAM && entry->virtual_width == scaled_tex_w && entry->virtual_height == scaled_tex_h))
 		{
 			// remove it and recreate it as a render target
 			delete entry;
@@ -645,32 +776,16 @@ 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
 		textures[dstAddr] = entry = g_texture_cache->CreateRenderTargetTexture(scaled_tex_w, scaled_tex_h);
 
-		entry->addr = dstAddr;
-		entry->hash = 0;
-
-		entry->realW = tex_w;
-		entry->realH = tex_h;
-
-		entry->virtualW = scaled_tex_w;
-		entry->virtualH = scaled_tex_h;
-
-		entry->format = dstFormat;
-		entry->mipLevels = 0;
-
-		entry->isRenderTarget = true;
-		entry->isNonPow2 = true;
-		entry->isDynamic = false;
+		// 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->SetHashes(TEXHASH_INVALID);
+		entry->type = TCET_EC_VRAM;
 	}
 
 	entry->frameCount = frameCount;