mixed commit:

in D3D and Opengl:
fixed one nasty bug in texture loading where if a dynamic texture keeps his format but the tlut format is changed, the try or reloading the texture in the same texture could cause a hang if the size of the resulting texture is different than the original (size in bytes)
Applied a ugly temporal hack to the texture conversor to solve efb to ram misalignments and effect distortions.
in D3D:
Pseudo implementation of logic ops using basic blending: the first 8 operations are "good approximations", the remaining 8 are bullshit :) if someone have a better approximation to emulate this logic please let me know.
please test if i don't break anything in the process and test Mario kart wee you will get a nice surprise.:)
 

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4656 8ced0084-cf51-0410-be5f-012b33b47a6e

Source/Plugins/Plugin_VideoDX9/Src/BPFunctions.cpp

@@ -71,7 +71,7 @@ void SetDitherMode(const BPCmd &bp)
 }
 void SetLogicOpMode(const BPCmd &bp)
 {
-	// Logic op blending. D3D can't do this but can fake some modes.
+	Renderer::SetLogicOpMode();
 }
 
 void SetColorMask(const BPCmd &bp)

Source/Plugins/Plugin_VideoDX9/Src/D3DTexture.cpp

@@ -103,13 +103,20 @@ LPDIRECT3DTEXTURE9 CreateTexture2D(const u8* buffer, const int width, const int
 		break;
 	case D3DFMT_A8R8G8B8:
 		{
-			u32* pIn = pBuffer;
-			for (int y = 0; y < height; y++)
+			/*if(Lock.Pitch == width * 4)
 			{
-				u32* pBits = (u32*)((u8*)Lock.pBits + (y * Lock.Pitch));
-				memcpy(pBits, pIn, width * 4);
-				pIn += pitch;
+				memcpy(Lock.pBits,buffer,width*height*4);
 			}
+			else
+			{*/
+				u32* pIn = pBuffer;
+				for (int y = 0; y < height; y++)
+				{
+					u32* pBits = (u32*)((u8*)Lock.pBits + (y * Lock.Pitch));
+					memcpy(pBits, pIn, width * 4);
+					pIn += pitch;
+				}
+			//}
 		}
 		break;
 	case D3DFMT_DXT1:
@@ -122,6 +129,25 @@ LPDIRECT3DTEXTURE9 CreateTexture2D(const u8* buffer, const int width, const int
 	return pTexture;
 }
 
+LPDIRECT3DTEXTURE9 CreateOnlyTexture2D(const int width, const int height, D3DFORMAT fmt)
+{
+	LPDIRECT3DTEXTURE9 pTexture;
+	// crazy bitmagic, sorry :)
+	bool isPow2 = !((width&(width-1)) || (height&(height-1)));
+	bool bExpand = false;
+	HRESULT hr;
+	// TODO(ector): Allow mipmaps for non-pow textures on newer cards?
+	// TODO(ector): Use the game-specified mipmaps?
+	if (!isPow2)
+		hr = dev->CreateTexture(width, height, 1, 0, fmt, D3DPOOL_MANAGED, &pTexture, NULL);
+	else
+		hr = dev->CreateTexture(width, height, 0, D3DUSAGE_AUTOGENMIPMAP, fmt, D3DPOOL_MANAGED, &pTexture, NULL);
+
+	if (FAILED(hr))
+		return 0;
+	return pTexture;
+}
+
 void ReplaceTexture2D(LPDIRECT3DTEXTURE9 pTexture, const u8* buffer, const int width, const int height,const int pitch,  D3DFORMAT fmt)
 {
 	u32* pBuffer = (u32*)buffer;

Source/Plugins/Plugin_VideoDX9/Src/D3DTexture.h

@@ -25,4 +25,5 @@ namespace D3D
 	void ReplaceTexture2D(LPDIRECT3DTEXTURE9 pTexture, const u8* buffer, const int width, const int height,const int pitch,  D3DFORMAT fmt);
 	LPDIRECT3DTEXTURE9 CreateRenderTarget(const int width, const int height);
 	LPDIRECT3DSURFACE9 CreateDepthStencilSurface(const int width, const int height);
+	LPDIRECT3DTEXTURE9 CreateOnlyTexture2D(const int width, const int height, D3DFORMAT fmt);
 }

Source/Plugins/Plugin_VideoDX9/Src/Render.cpp

@@ -91,6 +91,86 @@ static const D3DBLEND d3dDestFactors[8] =
 	D3DBLEND_INVDESTALPHA
 };
 
+//		0	0x00
+//		1	Source & destination
+//		2	Source & ~destination
+//		3	Source
+//		4	~Source & destination
+//		5	Destination
+//		6	Source ^ destination =  Source & ~destination | ~Source & destination
+//		7	Source | destination
+
+//		8	~(Source | destination)
+//		9	~(Source ^ destination) = ~Source & ~destination | Source & destination
+//		10	~Destination
+//		11	Source | ~destination
+//		12	~Source
+//		13	~Source | destination
+//		14	~(Source & destination)
+//		15	0xff
+
+static const D3DBLENDOP d3dLogincOPop[16] =
+{
+	D3DBLENDOP_ADD,
+    D3DBLENDOP_ADD,
+    D3DBLENDOP_ADD,
+    D3DBLENDOP_ADD,
+    D3DBLENDOP_ADD,
+	D3DBLENDOP_ADD,
+	D3DBLENDOP_ADD,
+	D3DBLENDOP_ADD,
+	
+	D3DBLENDOP_REVSUBTRACT,
+	D3DBLENDOP_REVSUBTRACT,
+	D3DBLENDOP_SUBTRACT,
+	D3DBLENDOP_SUBTRACT,
+	D3DBLENDOP_REVSUBTRACT,
+	D3DBLENDOP_REVSUBTRACT,
+	D3DBLENDOP_SUBTRACT,
+	D3DBLENDOP_ADD
+};
+
+static const D3DBLEND d3dLogicOpSrcFactors[16] =
+{
+	D3DBLEND_ZERO,
+	D3DBLEND_DESTCOLOR,
+	D3DBLEND_INVDESTCOLOR,
+	D3DBLEND_ONE,
+	D3DBLEND_ZERO,
+	D3DBLEND_ZERO,
+	D3DBLEND_INVDESTCOLOR,
+	D3DBLEND_ONE,
+
+	D3DBLEND_ONE,
+	D3DBLEND_INVDESTCOLOR,
+	D3DBLEND_ONE,
+	D3DBLEND_ONE,
+	D3DBLEND_ONE,
+	D3DBLEND_ONE, 
+	D3DBLEND_ONE,
+	D3DBLEND_ONE
+};
+
+static const D3DBLEND d3dLogicOpDestFactors[16] =
+{
+	D3DBLEND_ZERO,
+	D3DBLEND_ZERO,
+	D3DBLEND_ZERO,
+	D3DBLEND_ZERO,
+	D3DBLEND_INVSRCCOLOR,
+	D3DBLEND_ONE,
+	D3DBLEND_INVSRCCOLOR,
+	D3DBLEND_ONE,
+
+	D3DBLEND_ONE,
+	D3DBLEND_SRCCOLOR,
+	D3DBLEND_ONE,
+	D3DBLEND_ONE,
+	D3DBLEND_ONE,
+	D3DBLEND_ONE, 
+	D3DBLEND_SRCCOLOR,
+	D3DBLEND_ONE
+};
 
 static const D3DCULL d3dCullModes[4] = 
 {
@@ -160,7 +240,7 @@ bool Renderer::Init()
 {
 	UpdateActiveConfig();
 	int fullScreenRes, w_temp, h_temp;
-	s_blendMode = 0;
+	s_blendMode = 0;	
 	int backbuffer_ms_mode = 0;  // g_ActiveConfig.iMultisampleMode;
 
 	sscanf(g_Config.cFSResolution, "%dx%d", &w_temp, &h_temp);
@@ -823,10 +903,10 @@ void Renderer::ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaE
 	D3D::dev->SetScissorRect(&sirc);	
 	if(zEnable)
 		D3D::SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
-	D3D::drawClearQuad(&sirc,color,(z & 0xFFFFFF) / float(0xFFFFFF),PixelShaderCache::GetClearProgram(),VertexShaderCache::GetSimpleVertexShader());	
+	D3D::drawClearQuad(&sirc,color ,(z & 0xFFFFFF) / float(0xFFFFFF),PixelShaderCache::GetClearProgram(),VertexShaderCache::GetSimpleVertexShader());	
 	if(zEnable)
 		D3D::SetRenderState(D3DRS_ZFUNC, d3dCmpFuncs[bpmem.zmode.func]);
-	//D3D::dev->Clear(0, NULL, (colorEnable ? D3DCLEAR_TARGET : 0)| ( zEnable ? D3DCLEAR_ZBUFFER : 0), color,(z & 0xFFFFFF) / float(0xFFFFFF), 0);			
+	//D3D::dev->Clear(0, NULL, (colorEnable ? D3DCLEAR_TARGET : 0)| ( zEnable ? D3DCLEAR_ZBUFFER : 0), color | ((alphaEnable)?0:0xFF000000),(z & 0xFFFFFF) / float(0xFFFFFF), 0);			
 	SetScissorRect();
 	UpdateViewport();
 }
@@ -838,7 +918,8 @@ void Renderer::SetBlendMode(bool forceUpdate)
 	// 2 - reverse subtract enable (else add)
 	// 3-5 - srcRGB function
 	// 6-8 - dstRGB function
-
+	if(bpmem.blendmode.logicopenable)
+		return;
 	u32 newval = bpmem.blendmode.subtract << 2;
 
     if (bpmem.blendmode.subtract) {
@@ -937,27 +1018,12 @@ void Renderer::RestoreAPIState()
     D3D::SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE);
 	SetScissorRect();
     SetColorMask();
-	SetBlendMode(true);	
+	SetLogicOpMode();	
 }
 
 void Renderer::SetGenerationMode()
 {
-	D3D::SetRenderState(D3DRS_CULLMODE, d3dCullModes[bpmem.genMode.cullmode]);
-
-	if (bpmem.genMode.cullmode == 3)
-	{
-		D3D::SetRenderState(D3DRS_COLORWRITEENABLE, 0);
-	}
-	else
-	{
-		DWORD write = 0;
-		if (bpmem.blendmode.alphaupdate) 
-			write = D3DCOLORWRITEENABLE_ALPHA;
-		if (bpmem.blendmode.colorupdate) 
-			write |= D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE;
-		
-		D3D::SetRenderState(D3DRS_COLORWRITEENABLE, write);
-	}
+	D3D::SetRenderState(D3DRS_CULLMODE, d3dCullModes[bpmem.genMode.cullmode]);	
 }
 
 void Renderer::SetDepthMode()
@@ -977,7 +1043,17 @@ void Renderer::SetDepthMode()
 
 void Renderer::SetLogicOpMode()
 {
-	//TODO
+	if (bpmem.blendmode.logicopenable) 
+	{
+        D3D::SetRenderState(D3DRS_ALPHABLENDENABLE, 1);
+		D3D::SetRenderState(D3DRS_BLENDOP, d3dLogincOPop[bpmem.blendmode.logicmode]);
+		D3D::SetRenderState(D3DRS_SRCBLEND, d3dLogicOpSrcFactors[bpmem.blendmode.logicmode]);
+		D3D::SetRenderState(D3DRS_DESTBLEND, d3dLogicOpDestFactors[bpmem.blendmode.logicmode]);
+	}
+	else
+	{
+		SetBlendMode(true);
+	}
 }
 
 void Renderer::SetDitherMode()

Source/Plugins/Plugin_VideoDX9/Src/TextureCache.cpp

@@ -133,7 +133,7 @@ void TextureCache::Cleanup()
 	}
 }
 
-TextureCache::TCacheEntry *TextureCache::Load(int stage, u32 address, int width, int height, int tex_format, int tlutaddr, int tlutfmt)
+/*TextureCache::TCacheEntry *TextureCache::Load(int stage, u32 address, int width, int height, int tex_format, int tlutaddr, int tlutfmt)
 {
 	if (address == 0)
 		return NULL;
@@ -203,6 +203,162 @@ TextureCache::TCacheEntry *TextureCache::Load(int stage, u32 address, int width,
 		}
 	}
 	
+	//PC_TexFormat pcfmt = TexDecoder_Decode(temp, ptr, expandedWidth, height, tex_format, tlutaddr, tlutfmt);
+	PC_TexFormat pcfmt = GetPC_TexFormat(tex_format, tlutfmt);
+
+	D3DFORMAT d3d_fmt;
+	switch (pcfmt) {
+	case PC_TEX_FMT_BGRA32:
+	case PC_TEX_FMT_RGBA32:
+		d3d_fmt = D3DFMT_A8R8G8B8;
+		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_A8L8; 
+		break;
+	case PC_TEX_FMT_IA8:
+		d3d_fmt = D3DFMT_A8L8;
+		break;
+	case PC_TEX_FMT_DXT1:
+		d3d_fmt = D3DFMT_DXT1;
+		break;
+	}
+	
+	//Make an entry in the table
+	TCacheEntry& entry = textures[texID];
+
+	entry.oldpixel = ((u32 *)ptr)[0];
+	if (g_ActiveConfig.bSafeTextureCache)
+		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(width, height, tex_format);
+	entry.isRenderTarget = false;
+	entry.isNonPow2 = ((width & (width - 1)) || (height & (height - 1)));
+	if (!skip_texture_create) {
+		entry.texture = D3D::CreateOnlyTexture2D(width, height, d3d_fmt);
+	}
+	D3DLOCKED_RECT Lock;
+	entry.texture->LockRect(0, &Lock, NULL, 0);
+	TexDecoder_DirectDecode((u8*)Lock.pBits,ptr,expandedWidth,height,Lock.Pitch,tex_format,tlutaddr,tlutfmt);
+	entry.texture->UnlockRect(0); 
+	entry.frameCount = frameCount;
+	entry.w = width;
+	entry.h = height;
+	entry.fmt = tex_format;
+	
+	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", FULL_DUMP_TEXTURES_DIR, 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);
+		//sprintf(szTemp, "%s\\txt_%04i_%i.png", g_Config.texDumpPath.c_str(), counter++, format); <-- Old method
+		if (!File::Exists(szTemp))
+			D3DXSaveTextureToFileA(szTemp,D3DXIFF_BMP,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;
+}*/
+
+TextureCache::TCacheEntry *TextureCache::Load(int stage, u32 address, int width, int height, int tex_format, int tlutaddr, int tlutfmt)
+{
+	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 expandedWidth  = (width + bsw)  & (~bsw);
+	int expandedHeight = (height + bsh) & (~bsh);
+
+	u32 hash_value;
+	u32 texID = address;
+	u32 texHash;
+
+	if (g_ActiveConfig.bSafeTextureCache || g_ActiveConfig.bDumpTextures)
+	{
+		texHash = TexDecoder_GetSafeTextureHash(ptr, expandedWidth, expandedHeight, tex_format, 0);
+		if (g_ActiveConfig.bSafeTextureCache)
+			hash_value = texHash;
+		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.
+ 			u32 tlutHash = TexDecoder_GetTlutHash(&texMem[tlutaddr], (tex_format == GX_TF_C4) ? 32 : 128);
+			texHash ^= tlutHash;
+			if (g_ActiveConfig.bSafeTextureCache)
+				texID ^= tlutHash;
+		}
+	}
+
+	bool skip_texture_create = false;
+	TexCache::iterator iter = textures.find(texID);
+
+	if (iter != textures.end())
+	{
+		TCacheEntry &entry = iter->second;
+
+		if (!g_ActiveConfig.bSafeTextureCache)
+			hash_value = ((u32 *)ptr)[0];
+
+		if (entry.isRenderTarget || ((address == entry.addr) && (hash_value == entry.hash)))
+		{
+			entry.frameCount = frameCount;
+			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.
+
+			if (width == entry.w && height==entry.h &&(tex_format | (tlutfmt << 16)) == entry.fmt)
+			{
+				skip_texture_create = true;
+			}
+			else
+			{
+				entry.Destroy(false);
+				textures.erase(iter);
+			}
+		}
+	}
+	
 	PC_TexFormat pcfmt = TexDecoder_Decode(temp, ptr, expandedWidth, height, tex_format, tlutaddr, tlutfmt);
 
 	D3DFORMAT d3d_fmt;
@@ -255,7 +411,7 @@ TextureCache::TCacheEntry *TextureCache::Load(int stage, u32 address, int width,
 	entry.frameCount = frameCount;
 	entry.w = width;
 	entry.h = height;
-	entry.fmt = tex_format;
+	entry.fmt = tex_format | (tlutfmt << 16);
 	
 	if (g_ActiveConfig.bDumpTextures)
 	{
@@ -286,8 +442,7 @@ TextureCache::TCacheEntry *TextureCache::Load(int stage, u32 address, int width,
 
 	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();

Source/Plugins/Plugin_VideoDX9/Src/TextureCache.h

@@ -40,7 +40,9 @@ public:
 		
 		int frameCount;
 		int w, h, fmt;
-		
+
+		float scaleX, scaleY; // Hires texutres need this
+
 		bool isRenderTarget;
 		bool isNonPow2;
 
@@ -51,6 +53,12 @@ public:
 			hash = 0;
 			paletteHash = 0;
 			oldpixel = 0;
+			addr = 0;
+			size_in_bytes = 0;
+			frameCount = 0;
+			scaleX = 1.0f;
+			scaleY = 1.0f;
+			isNonPow2 = true;
 		}
 		void Destroy(bool shutdown);
 		bool IntersectsMemoryRange(u32 range_address, u32 range_size);

Source/Plugins/Plugin_VideoDX9/Src/TextureConverter.cpp

@@ -363,8 +363,8 @@ void EncodeToRam(u32 address, bool bFromZBuffer, bool bIsIntensityFmt, u32 copyf
 	TextureConversionShader::SetShaderParameters(
 		(float)expandedWidth, 
 		expandedHeight * MValueY, 
-		ceilf(source.left * MValueX + 1.0f), 
-		ceilf(source.top * MValueY + 1.0f), 
+		source.left * MValueX, 
+		source.top * MValueY, 
 		sampleStride * MValueX, 
 		sampleStride * MValueY,
 		(float)Renderer::GetTargetWidth(),

Source/Plugins/Plugin_VideoDX9/Src/VertexManager.cpp

@@ -252,12 +252,15 @@ void Flush()
 
 			if (tentry) {
 				PixelShaderManager::SetTexDims(i, tentry->w, tentry->h, 0, 0);
+				if (tentry->scaleX != 1.0f || tentry->scaleY != 1.0f)
+					PixelShaderManager::SetCustomTexScale(i, tentry->scaleX, tentry->scaleY);
 			}
 			else
 			{
 				DEBUGGER_PAUSE_LOG_AT(NEXT_ERROR,true,{printf("Fail to load texture\n");});
 				ERROR_LOG(VIDEO, "error loading texture");
 			}
+
 		}
 	}
 	PixelShaderManager::SetTexturesUsed(0);