Merge branch 'master' into zcomploc-support

Conflicts:
	Source/Core/VideoCommon/Src/PixelShaderGen.cpp

1 files changed, 170 insertions, 165 deletions

diff --git a/Source/Core/VideoCommon/Src/TextureCacheBase.cpp b/Source/Core/VideoCommon/Src/TextureCacheBase.cpp
index d3b7ca14ba..00ff9610be 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"
 
@@ -23,28 +39,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());
@@ -88,12 +95,11 @@ 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)
+		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 +141,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 +172,19 @@ 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;
 }
 
 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,111 +193,85 @@ 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;
 	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);
+			if (entry->type != TCET_EC_VRAM)
+				entry->type = TCET_NORMAL;
 
-					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
@@ -301,23 +280,24 @@ 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)
 		{
 			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
 		}
 	}
 
+	// 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);
 
+	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) ?
 		GetPow2(std::max(width, height)) : !isPow2;
@@ -329,40 +309,27 @@ 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
-		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
+	// load mips - TODO: Loading mipmaps from tmem is untested!
 	if (texLevels > 1 && pcfmt != PC_TEX_FMT_NONE)
 	{
 		const unsigned int bsdepth = TexDecoder_GetTexelSizeInNibbles(texformat);
@@ -370,20 +337,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);
-			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);
+			*ptr += ((std::max(mipWidth, bsw) * std::max(mipHeight, bsh) * bsdepth) >> 1);
 			mipWidth >>= 1;
 			mipHeight >>= 1;
 			++level;
@@ -404,7 +382,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);
@@ -426,10 +404,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 +454,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 +464,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 +489,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 +502,6 @@ void TextureCache::CopyRenderTargetToTexture(u32 dstAddr, unsigned int dstFormat
 			cbufid = 7;
 			break;
 		}
-		
 	}
 	else if (isIntensity) 
 	{
@@ -627,15 +645,18 @@ 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_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))
 		{
-			texture_is_dynamic = entry->isDynamic;
+			if (entry->type == TCET_EC_DYNAMIC)
+			{
+				scaled_tex_w = tex_w;
+				scaled_tex_h = tex_h;
+			}
 		}
 		else
 		{
@@ -645,32 +666,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;