dolphin/Source/Plugins/Plugin_VideoDX9/Src/TextureCache.cpp

// 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 <d3dx9.h>

#include "Globals.h"
#include "Statistics.h"
#include "MemoryUtil.h"
#include "Hash.h"

#include "CommonPaths.h"
#include "FileUtil.h"

#include "D3DBase.h"
#include "D3DTexture.h"
#include "D3DUtil.h"
#include "FramebufferManager.h"
#include "PixelShaderCache.h"
#include "PixelShaderManager.h"
#include "VertexShaderManager.h"
#include "VertexShaderCache.h"

#include "Render.h"

#include "TextureDecoder.h"
#include "TextureCache.h"
#include "HiresTextures.h"
#include "TextureConverter.h"

#include "debugger/debugger.h"

u8 *TextureCache::temp = NULL;
TextureCache::TexCache TextureCache::textures;

extern int frameCount;

#define TEMP_SIZE (1024*1024*4)
#define TEXTURE_KILL_THRESHOLD 200

void TextureCache::TCacheEntry::Destroy(bool shutdown)
{
	if (texture)
		texture->Release();
	texture = 0;
	if (!isRenderTarget && !shutdown && !g_ActiveConfig.bSafeTextureCache)
	{
		u32 *ptr = (u32*)g_VideoInitialize.pGetMemoryPointer(addr);
		if (ptr && *ptr == hash)
			*ptr = oldpixel;
	}
}

void TextureCache::Init()
{
	temp = (u8*)AllocateMemoryPages(TEMP_SIZE);
	TexDecoder_SetTexFmtOverlayOptions(g_ActiveConfig.bTexFmtOverlayEnable, g_ActiveConfig.bTexFmtOverlayCenter);
	HiresTextures::Init(globals->unique_id);
}

void TextureCache::Invalidate(bool shutdown)
{
	for (TexCache::iterator iter = textures.begin(); iter != textures.end(); ++iter)
		iter->second.Destroy(shutdown);
	textures.clear();
	HiresTextures::Shutdown();
}

void TextureCache::InvalidateRange(u32 start_address, u32 size)
{
	TexCache::iterator iter = textures.begin();
	while (iter != textures.end())
	{
		int rangePosition = iter->second.IntersectsMemoryRange(start_address, size);
		if (rangePosition == 0)
		{
			iter->second.Destroy(false);
			textures.erase(iter++);
		}
		else 
		{
			++iter;		
		}
	}
}

void TextureCache::MakeRangeDynamic(u32 start_address, u32 size)
{
	TexCache::iterator iter = textures.begin();
	while (iter != textures.end())
	{
		int rangePosition = iter->second.IntersectsMemoryRange(start_address, size);
		if ( rangePosition == 0)
		{
			iter->second.hash = 0;
		}
		++iter;
	}
}

int TextureCache::TCacheEntry::IntersectsMemoryRange(u32 range_address, u32 range_size)
{
	if (addr + size_in_bytes < range_address)
		return -1;
	if (addr >= range_address + range_size)
		return 1;
	return 0;
}

void TextureCache::Shutdown()
{
	Invalidate(true);
	FreeMemoryPages(temp, TEMP_SIZE);
	temp = NULL;
}

void TextureCache::Cleanup()
{
	TexCache::iterator iter = textures.begin();
	while (iter != textures.end())
	{
		if (frameCount > TEXTURE_KILL_THRESHOLD + iter->second.frameCount)
		{
			iter->second.Destroy(false);
			iter = textures.erase(iter);			
		}
		else
		{
			++iter;
		}
	}
}

TextureCache::TCacheEntry *TextureCache::Load(int stage, u32 address, int width, int height, int tex_format, int tlutaddr, int tlutfmt,bool UseNativeMips, int maxlevel)
{
	if (address == 0)
		return NULL;

	u8 *ptr = g_VideoInitialize.pGetMemoryPointer(address);
	int bsw = TexDecoder_GetBlockWidthInTexels(tex_format) - 1; //TexelSizeInNibbles(format)*width*height/16;
	int bsh = TexDecoder_GetBlockHeightInTexels(tex_format) - 1; //TexelSizeInNibbles(format)*width*height/16;
	int bsdepth = TexDecoder_GetTexelSizeInNibbles(tex_format);
	int expandedWidth  = (width + bsw)  & (~bsw);
	int expandedHeight = (height + bsh) & (~bsh);

	u64 hash_value;
	u32 texID = address;
	u64 texHash;
	u32 FullFormat = tex_format;
	bool TextureIsDinamic = false;
	if ((tex_format == GX_TF_C4) || (tex_format == GX_TF_C8) || (tex_format == GX_TF_C14X2))
		u32 FullFormat = (tex_format | (tlutfmt << 16));

	if (g_ActiveConfig.bSafeTextureCache || g_ActiveConfig.bHiresTextures || g_ActiveConfig.bDumpTextures)
	{
		texHash =  TexDecoder_GetHash64(ptr,TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, tex_format),g_ActiveConfig.iSafeTextureCache_ColorSamples);
		if ((tex_format == GX_TF_C4) || (tex_format == GX_TF_C8) || (tex_format == GX_TF_C14X2))
		{
			// 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.
			u64 tlutHash = TexDecoder_GetHash64(&texMem[tlutaddr], TexDecoder_GetPaletteSize(tex_format),g_ActiveConfig.iSafeTextureCache_ColorSamples);
			texHash ^= tlutHash;
			if (g_ActiveConfig.bSafeTextureCache)
			{
				texID = texID ^ ((u32)(tlutHash & 0xFFFFFFFF)) ^ ((u32)((tlutHash >> 32) & 0xFFFFFFFF));
			}
		}
		if (g_ActiveConfig.bSafeTextureCache)
			hash_value = texHash;
	}

	bool skip_texture_create = false;
	TexCache::iterator iter = textures.find(texID);

	if (iter != textures.end())
	{
		TCacheEntry &entry = iter->second;

		if (!g_ActiveConfig.bSafeTextureCache)
		{
			if(entry.isRenderTarget || entry.isDinamic)
			{
				if(!g_ActiveConfig.bCopyEFBToTexture && g_ActiveConfig.bVerifyTextureModificationsByCPU)
				{
					hash_value =  TexDecoder_GetHash64(ptr,TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, tex_format),g_ActiveConfig.iSafeTextureCache_ColorSamples);
					if ((tex_format == GX_TF_C4) || (tex_format == GX_TF_C8) || (tex_format == GX_TF_C14X2))
					{
						hash_value ^= TexDecoder_GetHash64(&texMem[tlutaddr], TexDecoder_GetPaletteSize(tex_format),g_ActiveConfig.iSafeTextureCache_ColorSamples);
					}
				}
				else
				{
					hash_value = 0;
				}
			}
			else
			{
				hash_value = ((u32 *)ptr)[0];
			}
		}
		else
		{
			if(entry.isRenderTarget || entry.isDinamic)
			{
				if(g_ActiveConfig.bCopyEFBToTexture || !g_ActiveConfig.bVerifyTextureModificationsByCPU)
				{
					hash_value = 0;
				}
			}
		}
		if (((entry.isRenderTarget || entry.isDinamic) && hash_value == entry.hash && address == entry.addr) 
			|| ((address == entry.addr) && (hash_value == entry.hash) && FullFormat == entry.fmt/* && entry.MipLevels == maxlevel*/))
		{
			entry.frameCount = frameCount;
			entry.isDinamic = false;
			D3D::SetTexture(stage, entry.texture);
			return &entry;
		}
		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.
			TextureIsDinamic = (entry.isRenderTarget || entry.isDinamic) && !g_ActiveConfig.bCopyEFBToTexture;
			
			if (!entry.isRenderTarget &&
				((!entry.isDinamic && width == entry.w && height==entry.h && FullFormat == entry.fmt /* && entry.MipLevels < maxlevel*/) 
				|| (entry.isDinamic && entry.w == width && entry.h == height)))
			{
				skip_texture_create = true;
			}
			else
			{
				entry.Destroy(false);
				textures.erase(iter);
			}
		}
	}

	// Make an entry in the table
	TCacheEntry& entry = textures[texID];
	entry.isDinamic = TextureIsDinamic;
	PC_TexFormat pcfmt = PC_TEX_FMT_NONE;

	if (g_ActiveConfig.bHiresTextures)
	{
		// Load Custom textures
		char texPathTemp[MAX_PATH];
		int oldWidth = width;
		int oldHeight = height;

		sprintf(texPathTemp, "%s_%08x_%i", globals->unique_id, texHash, tex_format);
		pcfmt = HiresTextures::GetHiresTex(texPathTemp, &width, &height, tex_format, temp);

		if (pcfmt != PC_TEX_FMT_NONE)
		{
			expandedWidth = width;
			expandedHeight = height;
			entry.scaleX = (float) width / oldWidth;
			entry.scaleY = (float) height / oldHeight;
		}
	}

	if (pcfmt == PC_TEX_FMT_NONE)
		pcfmt = TexDecoder_Decode(temp, ptr, expandedWidth, expandedHeight, tex_format, tlutaddr, tlutfmt);

	D3DFORMAT d3d_fmt;
	bool swap_r_b = false;
	switch (pcfmt) {
	case PC_TEX_FMT_BGRA32:
		d3d_fmt = D3DFMT_A8R8G8B8;
		break;
	case PC_TEX_FMT_RGBA32:
		d3d_fmt = D3DFMT_A8R8G8B8;
		swap_r_b = true;
		break;
	case PC_TEX_FMT_RGB565:
		d3d_fmt = D3DFMT_R5G6B5;
		break;
	case PC_TEX_FMT_IA4_AS_IA8:
		d3d_fmt = D3DFMT_A8L8;
		break;
	case PC_TEX_FMT_I8:
	case PC_TEX_FMT_I4_AS_I8:
		d3d_fmt = D3DFMT_A8P8; // A hack which means the format is a packed
							   // 8-bit intensity texture. It is unpacked
							   // to A8L8 in D3DTexture.cpp
		break;
	case PC_TEX_FMT_IA8:
		d3d_fmt = D3DFMT_A8L8;
		break;
	case PC_TEX_FMT_DXT1:
		d3d_fmt = D3DFMT_DXT1;
		break;
	}

	entry.oldpixel = ((u32 *)ptr)[0];
	if (g_ActiveConfig.bSafeTextureCache || entry.isDinamic)
		entry.hash = hash_value;
	else
	{
		entry.hash = (u32)(((double)rand() / RAND_MAX) * 0xFFFFFFFF);
		((u32 *)ptr)[0] = entry.hash;		
	}

	entry.addr = address;
	entry.size_in_bytes = TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, tex_format);
	entry.isRenderTarget = false;
	bool isPow2 = !((width & (width - 1)) || (height & (height - 1)));
	entry.isNonPow2 = false;
	int TexLevels = (width > height)?width:height;
	TexLevels =  (isPow2 && UseNativeMips && (maxlevel > 0)) ? (int)(log((double)TexLevels)/log((double)2)) + 1 : ((isPow2)? 0 : 1);
	if(TexLevels > (maxlevel + 1) && maxlevel > 0)
		TexLevels = (maxlevel + 1);
	entry.MipLevels = maxlevel;
	if (!skip_texture_create)
	{
		entry.texture = D3D::CreateTexture2D((BYTE*)temp, width, height, expandedWidth, d3d_fmt, swap_r_b, TexLevels);
	}
	else
	{
		D3D::ReplaceTexture2D(entry.texture, (BYTE*)temp, width, height, expandedWidth, d3d_fmt, swap_r_b, 0);
	}
	if(TexLevels > 1 && pcfmt != PC_TEX_FMT_NONE)
	{
		int level = 1;
		int mipWidth = (width + 1) >> 1;
		int mipHeight = (height + 1) >> 1;
		ptr +=  entry.size_in_bytes;
		while((mipHeight || mipWidth) && (level < TexLevels))
		{
			u32 currentWidth = (mipWidth > 0)? mipWidth : 1;
			u32 currentHeight = (mipHeight > 0)? mipHeight : 1;
			expandedWidth  = (currentWidth + bsw)  & (~bsw);
			expandedHeight = (currentHeight + bsh) & (~bsh);
			TexDecoder_Decode(temp, ptr, expandedWidth, expandedHeight, tex_format, tlutaddr, tlutfmt);
			D3D::ReplaceTexture2D(entry.texture, (BYTE*)temp, currentWidth, currentHeight, expandedWidth, d3d_fmt, swap_r_b,level);
			u32 size = (max(mipWidth, bsw) * max(mipHeight, bsh) * bsdepth) >> 1;
			ptr +=  size;
			mipWidth >>= 1;
			mipHeight >>= 1;
			level++;
		}
	}
	entry.frameCount = frameCount;
	entry.w = width;
	entry.h = height;
	entry.Scaledw = width;
	entry.Scaledh = height;
	entry.fmt = FullFormat;
	
	if (g_ActiveConfig.bDumpTextures)
	{
		// dump texture to file
		char szTemp[MAX_PATH];
		char szDir[MAX_PATH];
		const char* uniqueId = globals->unique_id;
		bool bCheckedDumpDir = false;

		sprintf(szDir, "%s%s", File::GetUserPath(D_DUMPTEXTURES_IDX), uniqueId);

		if (!bCheckedDumpDir)
		{
			if (!File::Exists(szDir) || !File::IsDirectory(szDir))
				File::CreateDir(szDir);

			bCheckedDumpDir = true;
		}

		sprintf(szTemp, "%s/%s_%08x_%i.png", szDir, uniqueId, texHash, tex_format);

		if (!File::Exists(szTemp))
			D3DXSaveTextureToFileA(szTemp,D3DXIFF_PNG,entry.texture,0);
	}

	INCSTAT(stats.numTexturesCreated);
	SETSTAT(stats.numTexturesAlive, (int)textures.size());

	//Set the texture!
	D3D::SetTexture(stage, entry.texture);

	DEBUGGER_PAUSE_LOG_AT(NEXT_NEW_TEXTURE,true,{printf("A new texture (%d x %d) is loaded", width, height);});
	return &entry;
}

void TextureCache::CopyRenderTargetToTexture(u32 address, bool bFromZBuffer, bool bIsIntensityFmt, u32 copyfmt, int bScaleByHalf, const EFBRectangle &source_rect)
{
	int efb_w = source_rect.GetWidth();
	int efb_h = source_rect.GetHeight();

	int tex_w = (abs(source_rect.GetWidth()) >> bScaleByHalf);
	int tex_h = (abs(source_rect.GetHeight()) >> bScaleByHalf);
	//compensate the texture grow if supersampling is enabled to conserve memory usage
	float SuperSampleCompensation = g_ActiveConfig.iMultisampleMode + 1;
	SuperSampleCompensation = 1.0f / SuperSampleCompensation;
	float xScale = Renderer::GetTargetScaleX();
	float yScale = Renderer::GetTargetScaleY();
	
	int Scaledtex_w = (g_ActiveConfig.bCopyEFBScaled)?((int)(xScale * SuperSampleCompensation *  tex_w)):tex_w;
	int Scaledtex_h = (g_ActiveConfig.bCopyEFBScaled)?((int)(yScale * SuperSampleCompensation * tex_h)):tex_h;
	
	TexCache::iterator iter;	
	LPDIRECT3DTEXTURE9 tex = NULL;
	iter = textures.find(address);
	bool TextureIsDinamic = false;
	if (iter != textures.end())
	{
		if ((iter->second.isRenderTarget && iter->second.Scaledw == Scaledtex_w && iter->second.Scaledh == Scaledtex_h) 
			|| (iter->second.isDinamic && iter->second.w == tex_w && iter->second.h == tex_h))
		{
			tex = iter->second.texture;
			TextureIsDinamic = iter->second.isDinamic;
			iter->second.frameCount = frameCount;
		}
		else
		{
			// Remove it and recreate it as a render target
			if(iter->second.texture)
				iter->second.texture->Release();
			iter->second.texture = 0;
			textures.erase(iter);
		}
	}
	if(TextureIsDinamic)
	{
		Scaledtex_w = tex_w;
		Scaledtex_h = tex_h;
	}
	if(!tex)
	{
		TCacheEntry entry;
		entry.addr = address;
		entry.isRenderTarget = true;
		entry.hash = 0;
		entry.frameCount = frameCount;
		entry.w = tex_w;
		entry.h = tex_h;
		entry.Scaledw = Scaledtex_w;
		entry.Scaledh = Scaledtex_h;
		entry.fmt = copyfmt;
		entry.isNonPow2 = true;
		entry.isDinamic = false;
		D3D::dev->CreateTexture(Scaledtex_w, Scaledtex_h, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &entry.texture, 0);
		textures[address] = entry;
		tex = entry.texture;
	}

	// Make sure to resolve anything we need to read from.
	LPDIRECT3DTEXTURE9 read_texture = bFromZBuffer ? FBManager.GetEFBDepthTexture(source_rect) : FBManager.GetEFBColorTexture(source_rect);
	
	// We have to run a pixel shader, for color conversion.
	Renderer::ResetAPIState(); // reset any game specific settings
	if(!TextureIsDinamic || g_ActiveConfig.bCopyEFBToTexture)
	{
	
		float colmat[16]= {0.0f};
		float fConstAdd[4] = {0.0f};

		if (bFromZBuffer)
		{
			switch(copyfmt)
			{
				case 0: // Z4
				case 1: // Z8
					colmat[0] = colmat[4] = colmat[8] = colmat[12] = 1.0f;
					break;
				case 3: // Z16 //?
					colmat[1] = colmat[5] = colmat[9] = colmat[12] = 1.0f;
				case 11: // Z16 (reverse order)
					colmat[0] = colmat[4] = colmat[8] = colmat[13] = 1.0f;
					break;
				case 6: // Z24X8
					colmat[0] = colmat[5] = colmat[10] = 1.0f;
					break;
				case 9: // Z8M
					colmat[1] = colmat[5] = colmat[9] = colmat[13] = 1.0f;
					break;
				case 10: // Z8L
					colmat[2] = colmat[6] = colmat[10] = colmat[14] = 1.0f;
					break;
				case 12: // Z16L
					colmat[2] = colmat[6] = colmat[10] = colmat[13] = 1.0f;
					break;
				default:
					ERROR_LOG(VIDEO, "Unknown copy zbuf format: 0x%x", copyfmt);
					colmat[2] = colmat[5] = colmat[8] = 1.0f;
					break;
			}
		}
		else if (bIsIntensityFmt)
		{
			fConstAdd[0] = fConstAdd[1] = fConstAdd[2] = 16.0f/255.0f;
			switch (copyfmt)
			{
				case 0: // I4
				case 1: // I8
				case 2: // IA4
				case 3: // IA8
					colmat[0] = 0.257f; colmat[1] = 0.504f; colmat[2] = 0.098f;
					colmat[4] = 0.257f; colmat[5] = 0.504f; colmat[6] = 0.098f;
					colmat[8] = 0.257f; colmat[9] = 0.504f; colmat[10] = 0.098f;

					if (copyfmt < 2)
					{
						fConstAdd[3] = 16.0f / 255.0f;
						colmat[12] = 0.257f; colmat[13] = 0.504f; colmat[14] = 0.098f;
					}
					else// alpha
						colmat[15] = 1;

					break;
				default:
					ERROR_LOG(VIDEO, "Unknown copy intensity format: 0x%x", copyfmt);
					colmat[0] = colmat[5] = colmat[10] = colmat[15] = 1;
					break;
			}
		}
		else
		{
			switch (copyfmt)
			{
				case 0: // R4
				case 8: // R8
					colmat[0] = colmat[4] = colmat[8] = colmat[12] = 1;
					break;
				case 2: // RA4
				case 3: // RA8
					colmat[0] = colmat[4] = colmat[8] = colmat[15] = 1;
					break;

				case 7: // A8
					colmat[3] = colmat[7] = colmat[11] = colmat[15] = 1; 
					break;
				case 9: // G8
					colmat[1] = colmat[5] = colmat[9] = colmat[13] = 1;
					break;
				case 10: // B8
					colmat[2] = colmat[6] = colmat[10] = colmat[14] = 1;
					break;
				case 11: // RG8
					colmat[0] = colmat[4] = colmat[8] = colmat[13] = 1;
					break;
				case 12: // GB8
					colmat[1] = colmat[5] = colmat[9] = colmat[14] = 1;
					break;

				case 4: // RGB565
					colmat[0] = colmat[5] = colmat[10] = 1;
					fConstAdd[3] = 1; // set alpha to 1
					break;
				case 5: // RGB5A3
				case 6: // RGBA8
					colmat[0] = colmat[5] = colmat[10] = colmat[15] = 1;
					break;

				default:
					ERROR_LOG(VIDEO, "Unknown copy color format: 0x%x", copyfmt);
					colmat[0] = colmat[5] = colmat[10] = colmat[15] = 1;
					break;
			}
		}
		
		LPDIRECT3DSURFACE9 Rendersurf = NULL;
		tex->GetSurfaceLevel(0,&Rendersurf);
		D3D::dev->SetDepthStencilSurface(NULL);
		D3D::dev->SetRenderTarget(0, Rendersurf);
		
		D3DVIEWPORT9 vp;

		// Stretch picture with increased internal resolution
		vp.X = 0;
		vp.Y = 0;
		vp.Width  = Scaledtex_w;
		vp.Height = Scaledtex_h;
		vp.MinZ = 0.0f;
		vp.MaxZ = 1.0f;
		D3D::dev->SetViewport(&vp);
		RECT destrect;
		destrect.bottom = Scaledtex_h;
		destrect.left = 0;
		destrect.right = Scaledtex_w;
		destrect.top = 0;
		

		PixelShaderManager::SetColorMatrix(colmat, fConstAdd); // set transformation
		TargetRectangle targetSource = Renderer::ConvertEFBRectangle(source_rect);
		RECT sourcerect;
		sourcerect.bottom = targetSource.bottom;
		sourcerect.left = targetSource.left;
		sourcerect.right = targetSource.right;
		sourcerect.top = targetSource.top;


		if(bFromZBuffer)
		{
			if(bScaleByHalf || g_ActiveConfig.iMultisampleMode)
			{
				D3D::ChangeSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
				D3D::ChangeSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
			}
			else
			{
				D3D::ChangeSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
				D3D::ChangeSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
			}
		}
		else
		{
			D3D::ChangeSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
			D3D::ChangeSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		}
		

		D3DFORMAT bformat = FBManager.GetEFBDepthRTSurfaceFormat();
		int SSAAMode = g_ActiveConfig.iMultisampleMode;
		D3D::drawShadedTexQuad(
			read_texture,
			&sourcerect, 
			Renderer::GetFullTargetWidth() , 
			Renderer::GetFullTargetHeight(),
			Scaledtex_w,
			Scaledtex_h,
			((bformat != FOURCC_RAWZ && bformat != D3DFMT_D24X8) && bFromZBuffer)?  PixelShaderCache::GetDepthMatrixProgram(SSAAMode): PixelShaderCache::GetColorMatrixProgram(SSAAMode),
			VertexShaderCache::GetSimpleVertexShader(SSAAMode));
		Rendersurf->Release();	
	}
	
	if(!g_ActiveConfig.bCopyEFBToTexture)
	{
		textures[address].hash = TextureConverter::EncodeToRamFromTexture(
			address,
			read_texture,
			Renderer::GetFullTargetWidth(), 
			Renderer::GetFullTargetHeight(),
			xScale,
			yScale,
			(float)((Renderer::GetFullTargetWidth() - Renderer::GetTargetWidth()) / 2), 
			(float)((Renderer::GetFullTargetHeight() - Renderer::GetTargetHeight()) / 2) , 
			bFromZBuffer, 
			bIsIntensityFmt, 
			copyfmt, 
			bScaleByHalf, 
			source_rect);
	}
	
	D3D::RefreshSamplerState(0, D3DSAMP_MINFILTER);
	D3D::RefreshSamplerState(0, D3DSAMP_MAGFILTER);
	D3D::SetTexture(0,NULL);
	D3D::dev->SetRenderTarget(0, FBManager.GetEFBColorRTSurface());
	D3D::dev->SetDepthStencilSurface(FBManager.GetEFBDepthRTSurface());
	Renderer::RestoreAPIState();
	
}