From 70a45d06e0765a5cb7aecfdfac0324cd8047a696 Mon Sep 17 00:00:00 2001
From: gho tik <ghotik2002@yahoo.com>
Date: Sat, 13 Dec 2014 11:40:09 -0500
Subject: [PATCH] v2_03_05_src

Former-commit-id: a3ef0275db792a52ce0e35ecd64a4af50eebff73
---
 Include/dxwnd.h                        |   1 +
 build/dxwnd.dll                        |   4 +-
 build/dxwnd.exe                        |   2 +-
 build/dxwnd.ini                        |   4 +-
 build/readme-relnotes.txt              |   3 +
 dll/d3dtexture.cpp                     | 527 +++++++++++++++++++++++++
 dll/{texv4handle.cpp => ddtexture.cpp} |  67 +++-
 dll/dxwnd.cpp                          |   2 +-
 dll/dxwnd.vs2008.suo                   | Bin 280576 -> 280576 bytes
 dll/dxwnd.vs2008.vcproj                |  20 +-
 dll/hd3d.cpp                           | 198 +++++++++-
 dll/hd3d8.cpp                          |  68 ++++
 dll/hd3d9.cpp                          |  68 ++++
 host/dxwndhost.vs2008.suo              | Bin 128512 -> 128512 bytes
 14 files changed, 926 insertions(+), 38 deletions(-)
 create mode 100644 dll/d3dtexture.cpp
 rename dll/{texv4handle.cpp => ddtexture.cpp} (87%)
 create mode 100644 dll/hd3d8.cpp
 create mode 100644 dll/hd3d9.cpp

diff --git a/Include/dxwnd.h b/Include/dxwnd.h
index 9672597..9e00921 100644
--- a/Include/dxwnd.h
+++ b/Include/dxwnd.h
@@ -181,6 +181,7 @@
 
 #define EMULATEFLAGS		(EMULATEBUFFER | EMULATESURFACE | LOCKEDSURFACE)
 #define HANDLEFPS			(SHOWFPS | SHOWFPSOVERLAY | LIMITFPS | SKIPFPS)
+#define TEXTUREMASK			(TEXTUREHIGHLIGHT|TEXTUREDUMP|TEXTUREHACK|TEXTURETRANSP)
 
 // DxWnd host app data to be passed to the hook callback
 typedef struct TARGETMAP
diff --git a/build/dxwnd.dll b/build/dxwnd.dll
index 5c54bf3..dbf1421 100644
--- a/build/dxwnd.dll
+++ b/build/dxwnd.dll
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cb39f983940d6870059f12aedec119662e8fa477b9e6a8729cd11bdaea54899a
-size 525824
+oid sha256:dbfe732ec7cba24e2a540fa0a0275293d8f65b1922afeb0a190e5c7c5678e53f
+size 535552
diff --git a/build/dxwnd.exe b/build/dxwnd.exe
index cfaddd5..6b38334 100644
--- a/build/dxwnd.exe
+++ b/build/dxwnd.exe
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e5527a66a62d88b1d8b752729337b257c6c83e74098f5a158893b92552a1fc0c
+oid sha256:ef09812ea8000eca947a595d2c89257576af411f35834a2aecec9256e1c3a385
 size 532992
diff --git a/build/dxwnd.ini b/build/dxwnd.ini
index 62664c1..6ab9251 100644
--- a/build/dxwnd.ini
+++ b/build/dxwnd.ini
@@ -1,6 +1,6 @@
 [window]
-posx=50
-posy=50
+posx=1486
+posy=523
 sizx=320
 sizy=200
 lang=automatic
diff --git a/build/readme-relnotes.txt b/build/readme-relnotes.txt
index cd3ebff..34a3b4c 100644
--- a/build/readme-relnotes.txt
+++ b/build/readme-relnotes.txt
@@ -671,3 +671,6 @@ fix: DxWnd window position save now works on multiscreen desktop
 v2.03.04
 fix: changed surface capability policy so that "Risk II" works with identical surface pitches
 
+v2.03.05
+add: texture dump for d3d8 & d3d9. Note: highlight & hack yet to be implemented. d3d10 & d3d11 yet to be implemented. Texture types not complete.
+fix: handling of d3d10 (Assassin's Creed) 
\ No newline at end of file
diff --git a/dll/d3dtexture.cpp b/dll/d3dtexture.cpp
new file mode 100644
index 0000000..9e3006c
--- /dev/null
+++ b/dll/d3dtexture.cpp
@@ -0,0 +1,527 @@
+#define _CRT_SECURE_NO_WARNINGS
+
+#include <d3d9.h>
+#include "dxwnd.h"
+#include "dxwcore.hpp"
+#include "dxhook.h"
+#include "dxhelper.h"
+#include "syslibs.h"
+#include "stdio.h"
+
+extern unsigned int HashSurface(BYTE *, int, int, int);
+
+char *ExplainD3DSurfaceFormat(DWORD dwFormat)
+{
+	char *s;
+	switch(dwFormat){
+		case D3DFMT_UNKNOWN: s = "UNKNOWN"; break;
+		case D3DFMT_R8G8B8: s = "R8G8B8"; break;
+		case D3DFMT_A8R8G8B8: s = "A8R8G8B8"; break;
+		case D3DFMT_X8R8G8B8: s = "X8R8G8B8"; break;
+		case D3DFMT_R5G6B5: s = "R5G6B5"; break;
+		case D3DFMT_X1R5G5B5: s = "X1R5G5B5"; break;
+		case D3DFMT_A1R5G5B5: s = "A1R5G5B5"; break;
+		case D3DFMT_A4R4G4B4: s = "A4R4G4B4"; break;
+		case D3DFMT_R3G3B2: s = "R3G3B2"; break;
+		case D3DFMT_A8: s = "A8"; break;
+		case D3DFMT_A8R3G3B2: s = "A8R3G3B2"; break;
+		case D3DFMT_X4R4G4B4: s = "X4R4G4B4"; break;
+		case D3DFMT_A2B10G10R10: s = "A2B10G10R10"; break;
+		case D3DFMT_A8B8G8R8: s = "A8B8G8R8"; break;
+		case D3DFMT_X8B8G8R8: s = "X8B8G8R8"; break;
+		case D3DFMT_G16R16: s = "G16R16"; break;
+		case D3DFMT_A2R10G10B10: s = "A2R10G10B10"; break;
+		case D3DFMT_A16B16G16R16: s = "A16B16G16R16"; break;
+		case D3DFMT_A8P8: s = "A8P8"; break;
+		case D3DFMT_P8: s = "P8"; break;
+		case D3DFMT_L8: s = "L8"; break;
+		case D3DFMT_A8L8: s = "A8L8"; break;
+		case D3DFMT_A4L4: s = "A4L4"; break;
+		case D3DFMT_V8U8: s = "V8U8"; break;
+		case D3DFMT_L6V5U5: s = "L6V5U5"; break;
+		case D3DFMT_X8L8V8U8: s = "X8L8V8U8"; break;
+		case D3DFMT_Q8W8V8U8: s = "Q8W8V8U8"; break;
+		case D3DFMT_V16U16: s = "V16U16"; break;
+		case D3DFMT_A2W10V10U10: s = "A2W10V10U10"; break;
+		case D3DFMT_UYVY: s = "UYVY"; break;
+		case D3DFMT_R8G8_B8G8: s = "R8G8_B8G8"; break;
+		case D3DFMT_YUY2: s = "YUY2"; break;
+		case D3DFMT_G8R8_G8B8: s = "G8R8_G8B8"; break;
+		case D3DFMT_DXT1: s = "DXT1"; break;
+		case D3DFMT_DXT2: s = "DXT2"; break;
+		case D3DFMT_DXT3: s = "DXT3"; break;
+		case D3DFMT_DXT4: s = "DXT4"; break;
+		case D3DFMT_DXT5: s = "DXT5"; break;
+		case D3DFMT_D16_LOCKABLE: s = "D16_LOCKABLE"; break;
+		case D3DFMT_D32: s = "D32"; break;
+		case D3DFMT_D15S1: s = "D15S1"; break;
+		case D3DFMT_D24S8: s = "D24S8"; break;
+		case D3DFMT_D24X8: s = "D24X8"; break;
+		case D3DFMT_D24X4S4: s = "D24X4S4"; break;
+		case D3DFMT_D16: s = "D16"; break;
+		case D3DFMT_D32F_LOCKABLE: s = "D32F_LOCKABLE"; break;
+		case D3DFMT_D24FS8: s = "D24FS8"; break;
+		case D3DFMT_D32_LOCKABLE: s = "D32_LOCKABLE"; break;
+		case D3DFMT_S8_LOCKABLE: s = "S8_LOCKABLE"; break;
+		case D3DFMT_L16: s = "L16"; break;
+		case D3DFMT_VERTEXDATA: s = "VERTEXDATA"; break;
+		case D3DFMT_INDEX16: s = "INDEX16"; break;
+		case D3DFMT_INDEX32: s = "INDEX32"; break;
+		case D3DFMT_Q16W16V16U16: s = "Q16W16V16U16"; break;
+		case D3DFMT_MULTI2_ARGB8: s = "MULTI2_ARGB8"; break;
+		case D3DFMT_R16F: s = "R16F"; break;
+		case D3DFMT_G16R16F: s = "G16R16F"; break;
+		case D3DFMT_A16B16G16R16F: s = "A16B16G16R16F"; break;
+		case D3DFMT_R32F: s = "R32F"; break;
+		case D3DFMT_G32R32F: s = "G32R32F"; break;
+		case D3DFMT_A32B32G32R32F: s = "A32B32G32R32F"; break;
+		case D3DFMT_A1: s = "A1"; break;
+		case D3DFMT_A2B10G10R10_XR_BIAS: s = "A2B10G10R10_XR_BIAS"; break;
+		case D3DFMT_BINARYBUFFER: s = "BINARYBUFFER"; break;
+		default: s = "Unknown"; break;
+	}
+	return s;
+}
+
+static WORD Melt_123(WORD c1, WORD c2)
+{
+	WORD r1, r2, g1, g2, b1, b2;
+	WORD r, g, b;
+	r1 = (c1 & 0xF800) >> 11;
+	r2 = (c2 & 0xF800) >> 11;
+	g1 = (c1 & 0x07E0) >> 5;
+	g2 = (c2 & 0x07E0) >> 5;
+	b1 = (c1 & 0x001F) >> 0;
+	b2 = (c2 & 0x001F) >> 0;
+	r = (((r2 * 2) + r1) / 3) & 0x1F;
+	g = (((g2 * 2) + g1) / 3) & 0x3F;
+	b = (((b2 * 2) + b1) / 3) & 0x1F;
+	return (r << 11) | (g << 5) | (b << 0);
+}
+
+static DWORD Melt32_123(WORD c1, WORD c2)
+{
+	WORD r1, r2, g1, g2, b1, b2;
+	DWORD r, g, b;
+	r1 = (c1 & 0xF800) >> 11;
+	r2 = (c2 & 0xF800) >> 11;
+	g1 = (c1 & 0x07E0) >> 5;
+	g2 = (c2 & 0x07E0) >> 5;
+	b1 = (c1 & 0x001F) >> 0;
+	b2 = (c2 & 0x001F) >> 0;
+	r = (((r2 * 2) + r1) / 3) & 0x1F;
+	g = (((g2 * 2) + g1) / 3) & 0x3F;
+	b = (((b2 * 2) + b1) / 3) & 0x1F;
+	return (r << (16+3)) | (g << (8+2)) | (b << (0+3));
+}
+
+static DWORD Conv32(WORD c)
+{
+	DWORD r, g, b;
+	r = ((c & 0xF800) >> 11) & 0x1F;
+	g = ((c & 0x07E0) >> 5) & 0x3F;
+	b = ((c & 0x001F) >> 0) & 0x1F;
+	return (r << (16+3)) | (g << (8+2)) | (b << (0+3));
+}
+
+#define GRIDSIZE 16
+
+void D3DTextureHighlight(D3DSURFACE_DESC Desc, D3DLOCKED_RECT LockedRect)
+{
+	switch (Desc.Format){
+		case D3DFMT_X8R8G8B8: 
+		case D3DFMT_A8R8G8B8:
+			{
+				DWORD *p;
+				DWORD color;
+				color=(DWORD)(rand() & 0x00FFFFFF);
+				for(UINT y=0; y<Desc.Height; y++){
+					p = (DWORD *)LockedRect.pBits + ((y * LockedRect.Pitch) >> 2);
+					for(UINT x=0; x<Desc.Width; x++) *(p+x) = color;
+				}
+				for(UINT y=0; y<Desc.Height; y++){
+					p = (DWORD *)LockedRect.pBits + ((y * LockedRect.Pitch) >> 2);
+					for(UINT x=0; x<Desc.Width; x+=GRIDSIZE) *(p+x) = 0;
+					if((y%GRIDSIZE)==0) for(UINT x=0; x<Desc.Width; x++) *(p++) = 0;
+				}
+			}
+			break;
+		case D3DFMT_DXT3:
+			//if(Desc.Height) for(UINT y=0; y<(Desc.Height>>2); y+=2)
+			//	memset((BYTE *)LockedRect.pBits + (y * LockedRect.Pitch), 0x00, LockedRect.Pitch);
+		default:
+			break;
+	}
+}
+
+void D3DTextureDump(D3DSURFACE_DESC Desc, D3DLOCKED_RECT LockedRect)
+{
+	static BOOL DoOnce = TRUE;
+	static int MinTexX, MinTexY, MaxTexX, MaxTexY;
+	FILE *hf;
+	BITMAPFILEHEADER hdr;       // bitmap file-header 
+	BITMAPV4HEADER pbi;			// bitmap info-header  
+	int w, h; 
+	int iSurfaceSize, iScanLineSize;
+	char pszFile[MAX_PATH];
+	DWORD hash;
+
+	if(DoOnce){
+		char sProfilePath[MAX_PATH];
+		extern char *GetDxWndPath();
+		sprintf(sProfilePath, "%s\\dxwnd.ini", GetDxWndPath());
+		MinTexX=GetPrivateProfileInt("Texture", "MinTexX", 0, sProfilePath);
+		MaxTexX=GetPrivateProfileInt("Texture", "MaxTexX", 0, sProfilePath);
+		MinTexY=GetPrivateProfileInt("Texture", "MinTexY", 0, sProfilePath);
+		MaxTexY=GetPrivateProfileInt("Texture", "MaxTexY", 0, sProfilePath);
+		OutTrace("TextureDump: size min=(%dx%d) max=(%dx%d)\n", MinTexX, MinTexY, MaxTexX, MaxTexY);
+		sprintf_s(pszFile, MAX_PATH, "%s\\texture.out", GetDxWndPath());
+		CreateDirectory(pszFile, NULL);
+		DoOnce = FALSE;
+	}
+	
+	while (TRUE){ // fake loop 1
+		w = Desc.Width;
+		h = Desc.Height;
+		if((MinTexX && (w<MinTexX)) || (MinTexY && (h<MinTexY))) {
+			OutTrace("TextureDump: SKIP small texture\n");
+			break;
+		}
+		if((MaxTexX && (w>MaxTexX)) || (MaxTexY && (h>MaxTexY))) {
+			OutTrace("TextureDump: SKIP big texture\n");
+			break;
+		}
+		iSurfaceSize = Desc.Height * LockedRect.Pitch;
+
+		// calculate the bitmap hash
+		hash = 0;
+		switch (Desc.Format){
+			case D3DFMT_A4R4G4B4:
+			case D3DFMT_X4R4G4B4:
+			case D3DFMT_X8R8G8B8: 
+			case D3DFMT_A8R8G8B8: 
+			case D3DFMT_R5G6B5:
+			case D3DFMT_X1R5G5B5:
+			case D3DFMT_A1R5G5B5:
+			case D3DFMT_A8:
+				hash = HashSurface((BYTE *)LockedRect.pBits, LockedRect.Pitch, Desc.Width, Desc.Height);
+				break;
+			case D3DFMT_DXT1: 
+				hash = HashSurface((BYTE *)LockedRect.pBits, LockedRect.Pitch / 6, Desc.Width / 6, Desc.Height); 
+				break;
+			case D3DFMT_DXT2: 
+			case D3DFMT_DXT3: 
+				hash = HashSurface((BYTE *)LockedRect.pBits, LockedRect.Pitch / 4, Desc.Width / 4, Desc.Height); 
+				break;
+			case D3DFMT_DXT4: 
+			case D3DFMT_DXT5: 
+				hash = HashSurface((BYTE *)LockedRect.pBits, LockedRect.Pitch / 4, Desc.Width / 4, Desc.Height); 
+				break;
+			default:
+				char sMsg[80+1];
+				static BOOL DoOnce = TRUE;
+				if(DoOnce){
+					sprintf_s(sMsg, 80, "Unhandled texture type=%d(%s)", Desc.Format, ExplainD3DSurfaceFormat(Desc.Format));
+					MessageBox(0, sMsg, "WARN", MB_OK | MB_ICONEXCLAMATION);
+					DoOnce = FALSE;
+				}
+				break;
+		}
+
+		if(!hash) {
+			OutTrace("TextureDump: hash=NULL\n"); 
+			break; // almost certainly, an empty black surface!
+		}
+
+		dxw.dwTFlags = (hash == 0xEC2EE7CE) ? 0xFFFFFFFF : 0x00000000;
+
+		// Create the .BMP file. 
+		extern char *GetDxWndPath();
+		sprintf_s(pszFile, MAX_PATH, "%s\\texture.out\\texture.%03d.%03d.%s.%08X.bmp", 
+			GetDxWndPath(), Desc.Width, Desc.Height, ExplainD3DSurfaceFormat(Desc.Format), hash);
+		hf = fopen(pszFile, "wb");
+		if(!hf) break;
+
+		// set bmp invariant parameters
+		memset((void *)&pbi, 0, sizeof(BITMAPV4HEADER));
+		pbi.bV4Size = sizeof(BITMAPV4HEADER); 
+		pbi.bV4Width = Desc.Width;
+		pbi.bV4Height = Desc.Height;
+		pbi.bV4Planes = 1;
+		pbi.bV4V4Compression = BI_BITFIELDS;
+		pbi.bV4XPelsPerMeter = 1;
+		pbi.bV4YPelsPerMeter = 1;
+		pbi.bV4ClrUsed = 0;
+		pbi.bV4ClrImportant = 0;
+		pbi.bV4CSType = LCS_CALIBRATED_RGB;
+		hdr.bfType = 0x4d42;        // 0x42 = "B" 0x4d = "M"  
+		hdr.bfReserved1 = 0; 
+		hdr.bfReserved2 = 0; 
+
+		switch (Desc.Format){
+			case D3DFMT_X8R8G8B8: 
+			case D3DFMT_A8R8G8B8: 
+			case D3DFMT_DXT2:
+			case D3DFMT_DXT3:
+			case D3DFMT_DXT4:
+			case D3DFMT_DXT5:
+			case D3DFMT_A8:
+				pbi.bV4BitCount = 32;
+				pbi.bV4RedMask = 0x00FF0000;
+				pbi.bV4GreenMask = 0x0000FF00;
+				pbi.bV4BlueMask = 0x000000FF;
+				pbi.bV4AlphaMask = 0xFF000000;
+				break;
+			case D3DFMT_DXT1:
+				pbi.bV4BitCount = 16;
+				pbi.bV4RedMask = 0xF800;
+				pbi.bV4GreenMask = 0x07E0;
+				pbi.bV4BlueMask = 0x001F;
+				pbi.bV4AlphaMask = 0x0000;
+				break;
+			case D3DFMT_A4R4G4B4: // AoE III
+			case D3DFMT_X4R4G4B4:
+				pbi.bV4BitCount = 16;
+				pbi.bV4RedMask = 0x0F00;
+				pbi.bV4GreenMask = 0x00F0;
+				pbi.bV4BlueMask = 0x000F;
+				pbi.bV4AlphaMask = 0xF000;
+				break;
+			case D3DFMT_A1R5G5B5: //  AoE III
+			case D3DFMT_X1R5G5B5:
+				pbi.bV4BitCount = 16;
+				pbi.bV4RedMask = 0x7C00;
+				pbi.bV4GreenMask = 0x03E0;
+				pbi.bV4BlueMask = 0x001F;
+				pbi.bV4AlphaMask = 0x8000;
+				break;		
+			case D3DFMT_R5G6B5:
+				pbi.bV4BitCount = 16;
+				pbi.bV4RedMask = 0x7C00;
+				pbi.bV4GreenMask = 0x03E0;
+				pbi.bV4BlueMask = 0x001F;
+				pbi.bV4AlphaMask = 0x0000;
+				break;		
+		}
+
+		pbi.bV4SizeImage = ((pbi.bV4Width * pbi.bV4BitCount + 0x1F) & ~0x1F)/8 * pbi.bV4Height; 
+		iScanLineSize = ((pbi.bV4Width * pbi.bV4BitCount + 0x1F) & ~0x1F)/8;
+		pbi.bV4Height = - pbi.bV4Height;
+
+		// Compute the size of the entire file.  
+		hdr.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) + pbi.bV4Size + pbi.bV4ClrUsed * sizeof(RGBQUAD) + pbi.bV4SizeImage); 
+
+		// Compute the offset to the array of color indices.  
+		hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + pbi.bV4Size + pbi.bV4ClrUsed * sizeof (RGBQUAD); 
+
+		// Copy the BITMAPFILEHEADER into the .BMP file.  
+		fwrite((LPVOID)&hdr, sizeof(BITMAPFILEHEADER), 1, hf);
+
+		// Copy the BITMAPINFOHEADER and RGBQUAD array into the file.  
+		fwrite((LPVOID)&pbi, sizeof(BITMAPV4HEADER) + pbi.bV4ClrUsed * sizeof (RGBQUAD), 1, hf);
+
+		switch (Desc.Format){
+			case D3DFMT_X8R8G8B8: 
+			case D3DFMT_A8R8G8B8: 
+			case D3DFMT_A4R4G4B4:
+			case D3DFMT_X4R4G4B4:
+			case D3DFMT_A1R5G5B5:	//  AoE III
+			case D3DFMT_R5G6B5:		//  AoE III
+			case D3DFMT_X1R5G5B5:
+				{
+					// Copy the array of color indices into the .BMP file.  
+					for(int y=0; y<(int)Desc.Height; y++)
+						fwrite((BYTE *)LockedRect.pBits + (y*LockedRect.Pitch), iScanLineSize, 1, hf);
+				}
+				break;
+			case D3DFMT_A8:
+				{
+					// Copy the array of color indices into the .BMP file.  
+					BYTE *p = (BYTE *)LockedRect.pBits;
+					for(int y=0; y<(int)Desc.Height; y++)
+						for(int x=0; x<(int)Desc.Width; x++){
+							DWORD pixel;
+							pixel = 0xFF000000 | *p | (*p << 8) | (*p << 16); // gray color
+							fwrite((BYTE *)&pixel, sizeof(DWORD), 1, hf);
+							p++;
+						}
+				}
+				break;
+			case D3DFMT_DXT1: 
+				{
+					// Copy the array of color indices into the .BMP file.  
+					WORD *bm;
+					WORD *c;
+					int bmsize;
+					c = (WORD *)LockedRect.pBits;
+					bmsize = Desc.Width * Desc.Height * sizeof(WORD);
+					bm = (WORD *)malloc(bmsize);
+					for(int y=0; y<(int)Desc.Height; y+=4){
+						for(int x=0; x<(int)Desc.Width; x+=4){
+							WORD color_0, color_1, color_2, color_3;
+							color_0 = *c++;
+							color_1 = *c++;
+							color_2 = Melt_123(color_1, color_0);
+							color_3 = Melt_123(color_0, color_1);
+							for(int n=0; n<2; n++){
+								int dy;
+								WORD color_indexes = *c++;
+								WORD color;
+								for (int m=0; m<8; m++){
+									switch (color_indexes & 0x3){
+										case 0x00: color = color_0; break;
+										case 0x01: color = color_1; break;
+										case 0x02: color = color_2; break;
+										case 0x03: color = color_3; break;
+									}
+									dy = (m<4) ? 0 : 1;
+									color_indexes >>= 2;
+									int index = ((y+(2*n)+dy)*Desc.Width) + (x+(m%4));
+									if(index < bmsize/2) bm[index]=color;
+								}
+							}
+						}
+					}
+					fwrite((BYTE *)bm, bmsize, 1, hf);
+					free(bm);
+				}
+				break;
+			case D3DFMT_DXT2:
+			case D3DFMT_DXT3:
+				{
+					// Copy the array of color indices into the .BMP file.  
+					DWORD *bm;
+					WORD *c;
+					int bmsize;
+					c = (WORD *)LockedRect.pBits;
+					bmsize = Desc.Width * Desc.Height * sizeof(DWORD);
+					bm = (DWORD *)malloc(bmsize);
+					memset(bm, 0, bmsize);
+					for(int y=0; y<(int)Desc.Height; y+=4){
+						for(int x=0; x<(int)Desc.Width; x+=4){
+							WORD color_0, color_1;
+							DWORD dwcolor[4];
+							BYTE alpha[16];
+							WORD *pAlpha;
+							pAlpha = (WORD *)c;
+							for(int row=0; row<4; row++){
+								WORD a = *c++;
+								for(int col=0; col<4; col++){
+									alpha[(row<<2)+col] = (a & 0xF);
+									a >>= 4;
+								}
+							}
+							color_0 = *c++;
+							color_1 = *c++;
+							dwcolor[0] = Conv32(color_0);
+							dwcolor[1] = Conv32(color_1);
+							dwcolor[2] = Melt32_123(color_1, color_0);
+							dwcolor[3] = Melt32_123(color_0, color_1);
+							for(int n=0; n<2; n++){
+								int dy;
+								WORD color_indexes = *c++;
+								DWORD color;
+								for (int m=0; m<8; m++){
+									dy = (m<4) ? 0 : 1;
+									color = dwcolor[color_indexes & 0x3] & 0x00FFFFFF;
+									dy = (m<4) ? 0 : 1;
+									color_indexes >>= 2;
+									int index = ((y+(2*n)+dy)*Desc.Width) + (x+(m%4));
+									int alpha_index = (((2*n) + dy)<<2) + (m % 4);
+									//if(index < bmsize/4) bm[index] = color | 0xFF000000; // uncomment to get rid of alpha channel
+									if(index < bmsize/4) bm[index] = color | (alpha[alpha_index]<<28);
+								}
+							}						
+						}
+					}
+					fwrite((BYTE *)bm, bmsize, 1, hf);
+					free(bm);
+				}
+				break;
+			case D3DFMT_DXT4:
+			case D3DFMT_DXT5:
+				{
+					// Copy the array of color indices into the .BMP file.  
+					DWORD *bm;
+					WORD *c;
+					int bmsize;
+					c = (WORD *)LockedRect.pBits;
+					bmsize = Desc.Width * Desc.Height * sizeof(DWORD);
+					bm = (DWORD *)malloc(bmsize);
+					memset(bm, 0, bmsize);
+					for(int y=0; y<(int)Desc.Height; y+=4){
+						for(int x=0; x<(int)Desc.Width; x+=4){
+							WORD color_0, color_1;
+							DWORD dwcolor[4];
+							DWORD alpha[8];
+							//  alpha section (4 words) ....
+							alpha[1] = ((*c) >> 8) & 0xFF;
+							alpha[0] = (*c) & 0xFF;
+							c++;
+							if(alpha[0] > alpha[1])
+							{
+								// 6 interpolated alpha values.
+								alpha[2] = ((6*alpha[0]) + (1*alpha[1])) / 7; // bit code 010
+								alpha[3] = ((5*alpha[0]) + (2*alpha[1])) / 7; // bit code 011
+								alpha[4] = ((4*alpha[0]) + (3*alpha[1])) / 7; // bit code 100
+								alpha[5] = ((3*alpha[0]) + (4*alpha[1])) / 7; // bit code 101
+								alpha[6] = ((2*alpha[0]) + (5*alpha[1])) / 7; // bit code 110
+								alpha[7] = ((1*alpha[0]) + (6*alpha[1])) / 7; // bit code 111
+							}
+							else 
+							{
+								// 4 interpolated alpha values.
+								alpha[2] = ((4*alpha[0]) + (1*alpha[1])) / 5; // bit code 010
+								alpha[3] = ((3*alpha[0]) + (2*alpha[1])) / 5; // bit code 011
+								alpha[4] = ((2*alpha[0]) + (3*alpha[1])) / 5; // bit code 100
+								alpha[5] = ((1*alpha[0]) + (4*alpha[1])) / 5; // bit code 101
+								alpha[6] = 0x00;                              // bit code 110 (fully transparent)
+								alpha[7] = 0xFF;                              // bit code 111 (fully opaque)
+							}
+							BYTE *pAlpha = (BYTE *)c;
+							c += 3;
+							color_0 = *c++;
+							color_1 = *c++;
+							dwcolor[0] = Conv32(color_0);
+							dwcolor[1] = Conv32(color_1);
+							dwcolor[2] = Melt32_123(color_1, color_0);
+							dwcolor[3] = Melt32_123(color_0, color_1);
+							for(int n=0; n<2; n++){
+								int dy;
+								DWORD dwAlpha_indexes = (*(pAlpha+0) & 0x0000FF) | ((*(pAlpha+1)<<8) & 0x00FF00) | ((*(pAlpha+2)<<16) & 0xFF0000);
+								pAlpha += 3;
+								DWORD alpha_color;
+								WORD color_indexes = *c++;
+								DWORD color;
+								for (int m=0; m<8; m++){
+									alpha_color = (alpha[dwAlpha_indexes & 0x7] << 24) & 0xFF000000;
+									dy = (m<4) ? 0 : 1;
+									dwAlpha_indexes >>= 3;
+									color = dwcolor[color_indexes & 0x3] & 0x00FFFFFF;
+									dy = (m<4) ? 0 : 1;
+									color_indexes >>= 2;
+									int index = ((y+(2*n)+dy)*Desc.Width) + (x+(m%4));
+									if(index < bmsize/4) bm[index] = color | alpha_color;
+								}
+							}						
+						}
+					}
+					fwrite((BYTE *)bm, bmsize, 1, hf);
+					free(bm);	
+				}
+			default:
+				break;
+		}
+		// Close the .BMP file.  
+		if(hf) fclose(hf);
+		break;
+	} // end of fake loop 1
+}
+
+void D3DTextureHack(D3DSURFACE_DESC Desc, D3DLOCKED_RECT LockedRect)
+{
+}
+
+void D3DTextureTransp(D3DSURFACE_DESC Desc, D3DLOCKED_RECT LockedRect)
+{
+}
diff --git a/dll/texv4handle.cpp b/dll/ddtexture.cpp
similarity index 87%
rename from dll/texv4handle.cpp
rename to dll/ddtexture.cpp
index 4e1ed94..0872c59 100644
--- a/dll/texv4handle.cpp
+++ b/dll/ddtexture.cpp
@@ -55,7 +55,7 @@ static unsigned int Hash(BYTE *buf, int len)
    return hash;
 }
 
-static unsigned int HashSurface(BYTE *buf, int pitch, int width, int height)
+unsigned int HashSurface(BYTE *buf, int pitch, int width, int height)
 {
    unsigned int b    = 378551;
    unsigned int a    = 63689;
@@ -70,6 +70,50 @@ static unsigned int HashSurface(BYTE *buf, int pitch, int width, int height)
    return hash;
 }
 
+static char *SurfaceType(DDPIXELFORMAT ddpfPixelFormat)
+{
+	static char sSurfaceType[81];
+	char sColorType[21];
+	DWORD mask;
+	int i, count;
+	strcpy(sSurfaceType, "");
+	// red
+	mask=ddpfPixelFormat.dwRBitMask;
+	for (i=0, count=0; i<32; i++) {
+		if(mask & 0x1) count++;
+		mask >>= 1;
+	}
+	sprintf(sColorType, "R%d", count);
+	strcat(sSurfaceType, sColorType);
+	// green
+	mask=ddpfPixelFormat.dwGBitMask;
+	for (i=0, count=0; i<32; i++) {
+		if(mask & 0x1) count++;
+		mask >>= 1;
+	}
+	sprintf(sColorType, "G%d", count);
+	strcat(sSurfaceType, sColorType);
+	// blue
+	mask=ddpfPixelFormat.dwBBitMask;
+	for (i=0, count=0; i<32; i++) {
+		if(mask & 0x1) count++;
+		mask >>= 1;
+	}
+	sprintf(sColorType, "B%d", count);
+	strcat(sSurfaceType, sColorType);
+	// alpha channel
+	mask=ddpfPixelFormat.dwRGBAlphaBitMask;
+	if(mask){
+		for (i=0, count=0; i<32; i++) {
+			if(mask & 0x1) count++;
+			mask >>= 1;
+		}
+		sprintf(sColorType, "A%d", count);
+		strcat(sSurfaceType, sColorType);
+	}
+	return sSurfaceType;
+}
+
 void TextureHighlight(LPDIRECTDRAWSURFACE s)
 {
 	DDSURFACEDESC2 ddsd;
@@ -150,6 +194,7 @@ static void TextureDump(LPDIRECTDRAWSURFACE s)
 	HRESULT res;
 	static int MinTexX, MinTexY, MaxTexX, MaxTexY;
 	static BOOL DoOnce = TRUE;
+	char pszFile[MAX_PATH];
 
 	if(DoOnce){
 		char sProfilePath[MAX_PATH];
@@ -159,6 +204,8 @@ static void TextureDump(LPDIRECTDRAWSURFACE s)
 		MinTexY=GetPrivateProfileInt("Texture", "MinTexY", 0, sProfilePath);
 		MaxTexY=GetPrivateProfileInt("Texture", "MaxTexY", 0, sProfilePath);
 		OutTrace("TextureDump: size min=(%dx%d) max=(%dx%d)\n", MinTexX, MinTexY, MaxTexX, MaxTexY);
+		sprintf_s(pszFile, MAX_PATH, "%s\\texture.out", GetDxWndPath());
+		CreateDirectory(pszFile, NULL);
 		DoOnce = FALSE;
 	}
 
@@ -191,14 +238,10 @@ static void TextureDump(LPDIRECTDRAWSURFACE s)
 
 		iSurfaceSize = ddsd.dwHeight * ddsd.lPitch;
 
-		//HANDLE hf;					// file handle  
 		FILE *hf;
 		BITMAPFILEHEADER hdr;       // bitmap file-header 
 		BITMAPV4HEADER pbi;			// bitmap info-header  
-		//DWORD dwTmp; 
-		char pszFile[MAX_PATH];
 
-		//pbih = (PBITMAPINFOHEADER)&pbi; 
 		memset((void *)&pbi, 0, sizeof(BITMAPV4HEADER));
 		pbi.bV4Size = sizeof(BITMAPV4HEADER); 
 		pbi.bV4Width = ddsd.dwWidth;
@@ -217,7 +260,6 @@ static void TextureDump(LPDIRECTDRAWSURFACE s)
 		pbi.bV4BlueMask = ddsd.ddpfPixelFormat.dwBBitMask;
 		pbi.bV4AlphaMask = ddsd.ddpfPixelFormat.dwRGBAlphaBitMask;
 		pbi.bV4CSType = LCS_CALIBRATED_RGB;
-		//pbi.bV4CSType = 0xFFFFFFFF;
 		iScanLineSize = ((pbi.bV4Width * pbi.bV4BitCount + 0x1F) & ~0x1F)/8;
 
 		// calculate the bitmap hash
@@ -229,7 +271,8 @@ static void TextureDump(LPDIRECTDRAWSURFACE s)
 		}
 
 		// Create the .BMP file. 
-		sprintf_s(pszFile, 80, "%s\\texture.out\\texture.%03d.%03d.%08X.bmp", GetDxWndPath(), ddsd.dwWidth, ddsd.dwHeight, hash);
+		sprintf_s(pszFile, MAX_PATH, "%s\\texture.out\\texture.%03d.%03d.%s.%08X.bmp", 
+			GetDxWndPath(), ddsd.dwWidth, ddsd.dwHeight, SurfaceType(ddsd.ddpfPixelFormat), hash);
 		hf = fopen(pszFile, "wb");
 		if(!hf) break;
 
@@ -302,7 +345,8 @@ static void TextureHack(LPDIRECTDRAWSURFACE s)
 		if(!hash) break; // almost certainly, an empty black surface!
 
 		// Look for the .BMP file. 
-		sprintf_s(pszFile, 80, "%s\\texture.in\\texture.%03d.%03d.%08X.bmp", GetDxWndPath(), ddsd.dwWidth, ddsd.dwHeight, hash);
+		sprintf_s(pszFile, MAX_PATH, "%s\\texture.out\\texture.%03d.%03d.%s.%08X.bmp", 
+			GetDxWndPath(), ddsd.dwWidth, ddsd.dwHeight, SurfaceType(ddsd.ddpfPixelFormat), hash);
 		hf = fopen(pszFile, "rb");
 		if(!hf) break; // no updated texture to load
 
@@ -350,8 +394,8 @@ static void TextureHack(LPDIRECTDRAWSURFACE s)
 
 void TextureHandling(LPDIRECTDRAWSURFACE s)
 {
-	OutTrace("TextureHandling: dxw.dwFlags5 = %x\n", dxw.dwFlags5 & (TEXTUREHIGHLIGHT|TEXTUREDUMP|TEXTUREHACK));
-	switch(dxw.dwFlags5 & (TEXTUREHIGHLIGHT|TEXTUREDUMP|TEXTUREHACK)){
+	//OutTrace("TextureHandling(1-7): dxw.dwFlags5 = %x\n", dxw.dwFlags5 & (TEXTUREHIGHLIGHT|TEXTUREDUMP|TEXTUREHACK));
+	switch(dxw.dwFlags5 & TEXTUREMASK){
 		default:
 		case TEXTUREHIGHLIGHT: 
 			TextureHighlight(s);
@@ -362,5 +406,8 @@ void TextureHandling(LPDIRECTDRAWSURFACE s)
 		case TEXTUREHACK:
 			TextureHack(s);
 			break;
+		case TEXTURETRANSP:
+			//TextureTransp(s);
+			break;
 	}
 }
diff --git a/dll/dxwnd.cpp b/dll/dxwnd.cpp
index 23b4043..d9e42b1 100644
--- a/dll/dxwnd.cpp
+++ b/dll/dxwnd.cpp
@@ -24,7 +24,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "dxwnd.h"
 #include "dxwcore.hpp"
 
-#define VERSION "2.03.04"
+#define VERSION "2.03.05"
 #define DXWACTIVATESINGLETASK 1 // comment to allow multiple task activations
 
 #define DDTHREADLOCK 1
diff --git a/dll/dxwnd.vs2008.suo b/dll/dxwnd.vs2008.suo
index 851da909d86430d81f26e339b49db250206edd04..d6281e057caadb2bfed0aa0e947df4b998a29b05 100644
GIT binary patch
delta 28645
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
BgS-F$

delta 19265
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
aVoeQSE3s<~U+WaCR55dAN_jz4^nU>}Hio(Y

diff --git a/dll/dxwnd.vs2008.vcproj b/dll/dxwnd.vs2008.vcproj
index a94f6ca..d862672 100644
--- a/dll/dxwnd.vs2008.vcproj
+++ b/dll/dxwnd.vs2008.vcproj
@@ -221,6 +221,10 @@
 				RelativePath=".\advapi.cpp"
 				>
 			</File>
+			<File
+				RelativePath=".\d3dtexture.cpp"
+				>
+			</File>
 			<File
 				RelativePath=".\ddproxy.cpp"
 				>
@@ -245,6 +249,10 @@
 					/>
 				</FileConfiguration>
 			</File>
+			<File
+				RelativePath=".\ddtexture.cpp"
+				>
+			</File>
 			<File
 				RelativePath=".\dinput.cpp"
 				>
@@ -365,6 +373,14 @@
 				RelativePath=".\hd3d7.cpp"
 				>
 			</File>
+			<File
+				RelativePath=".\hd3d8.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\hd3d9.cpp"
+				>
+			</File>
 			<File
 				RelativePath=".\hotpatch.cpp"
 				>
@@ -401,10 +417,6 @@
 				RelativePath=".\smack.cpp"
 				>
 			</File>
-			<File
-				RelativePath=".\texv4handle.cpp"
-				>
-			</File>
 			<File
 				RelativePath=".\user32.cpp"
 				>
diff --git a/dll/hd3d.cpp b/dll/hd3d.cpp
index 5fd8c73..8985c54 100644
--- a/dll/hd3d.cpp
+++ b/dll/hd3d.cpp
@@ -9,6 +9,7 @@
 #include "dxhook.h"
 #include "dxhelper.h"
 #include "syslibs.h"
+#include "stdio.h"
 #include "hd3d.doc.hpp" // fake include to hold documentation
 
 #define HOOKD3D10ANDLATER 1
@@ -32,6 +33,7 @@ HRESULT WINAPI voidDirect3DShaderValidatorCreate9(void);
 void WINAPI voidDebugSetLevel(void);
 void WINAPI voidDebugSetMute(void);
 BOOL WINAPI voidDisableD3DSpy(void);
+BOOL WINAPI extDisableD3DSpy(void);
 
 // IDirect3D8/9 methods 
 
@@ -51,6 +53,7 @@ typedef HRESULT (WINAPI *D3DGetDeviceCaps_Type)(void *, UINT, D3DDEVTYPE, D3DCAP
 typedef HMONITOR (WINAPI *GetAdapterMonitor_Type)(void *, UINT);
 typedef HRESULT (WINAPI *CreateDevice_Type)(void *, UINT, D3DDEVTYPE, HWND, DWORD, void *, void **);
 typedef HRESULT (WINAPI *CreateDeviceEx_Type)(void *, UINT, D3DDEVTYPE, HWND, DWORD, void *, D3DDISPLAYMODEEX *, void **);
+typedef BOOL (WINAPI *DisableD3DSpy_Type)(void);
 
 HRESULT WINAPI extRegisterSoftwareDevice(void *, void*);
 UINT WINAPI extGetAdapterCount8(void *);
@@ -84,6 +87,7 @@ GetAdapterMonitor_Type pGetAdapterMonitor = 0;
 CreateDevice_Type pCreateDevice8 = 0;
 CreateDevice_Type pCreateDevice9 = 0;
 CreateDeviceEx_Type pCreateDeviceEx = 0;
+DisableD3DSpy_Type pDisableD3DSpy = 0;
 
 // IDirect3DDevice8/9 methods
 
@@ -102,6 +106,9 @@ typedef UINT (WINAPI *GetNumberOfSwapChains_Type)(void *);
 typedef HRESULT (WINAPI *BeginStateBlock_Type)(void *);
 typedef HRESULT (WINAPI *EndStateBlock8_Type)(void *, DWORD *);
 typedef HRESULT (WINAPI *EndStateBlock9_Type)(void *, IDirect3DStateBlock9**);
+typedef HRESULT (WINAPI *CreateTexture8_Type)(void *, UINT, UINT, UINT, DWORD, D3DFORMAT, D3DPOOL, void **);
+typedef HRESULT (WINAPI *CreateTexture9_Type)(void *, UINT, UINT, UINT, DWORD, D3DFORMAT, D3DPOOL, void **, HANDLE *);
+typedef HRESULT (WINAPI *CopyRects_Type)(void *, void *, CONST RECT *, UINT, void *, CONST POINT *);
 
 HRESULT WINAPI extTestCooperativeLevel(void *);
 HRESULT WINAPI extGetDirect3D8(void *, void **);
@@ -119,6 +126,9 @@ HRESULT WINAPI extBeginStateBlock8(void *);
 HRESULT WINAPI extBeginStateBlock9(void *);
 HRESULT WINAPI extEndStateBlock8(void *, DWORD *);
 HRESULT WINAPI extEndStateBlock9(void *, IDirect3DStateBlock9**);
+HRESULT WINAPI extCreateTexture8(void *, UINT, UINT, UINT, DWORD, D3DFORMAT, D3DPOOL, void **);
+HRESULT WINAPI extCreateTexture9(void *, UINT, UINT, UINT, DWORD, D3DFORMAT, D3DPOOL, void **, HANDLE *);
+HRESULT WINAPI extCopyRects(void *, void *, CONST RECT *, UINT, void *, CONST POINT *);
 
 TestCooperativeLevel_Type pTestCooperativeLevel = 0;
 GetDirect3D8_Type pGetDirect3D8 = 0;
@@ -136,6 +146,21 @@ BeginStateBlock_Type pBeginStateBlock8 = 0;
 BeginStateBlock_Type pBeginStateBlock9 = 0;
 EndStateBlock8_Type pEndStateBlock8 = 0;
 EndStateBlock9_Type pEndStateBlock9 = 0;
+CreateTexture8_Type pCreateTexture8 = 0;
+CreateTexture9_Type pCreateTexture9 = 0;
+CopyRects_Type pCopyRects = 0;
+
+// IDirect3DTexture8/9 methods
+
+typedef HRESULT (WINAPI *LockRect_Type)(void *, UINT, D3DLOCKED_RECT *, CONST RECT *, DWORD);
+typedef HRESULT (WINAPI *UnlockRect_Type)(void *, UINT);
+
+HRESULT WINAPI extLockRect(void *, UINT, D3DLOCKED_RECT *, CONST RECT *, DWORD);
+HRESULT WINAPI extUnlockRect8(void *, UINT);
+HRESULT WINAPI extUnlockRect9(void *, UINT);
+
+LockRect_Type pLockRect = NULL;
+UnlockRect_Type pUnlockRect = NULL;
 
 // to sort ...
 
@@ -160,7 +185,8 @@ typedef HRESULT (WINAPI *D3D10CreateDevice1_Type)(IDXGIAdapter *, D3D10_DRIVER_T
 typedef HRESULT (WINAPI *D3D10CreateDeviceAndSwapChain1_Type)(IDXGIAdapter *, D3D10_DRIVER_TYPE, HMODULE, UINT, UINT, DXGI_SWAP_CHAIN_DESC *, IDXGISwapChain **, ID3D10Device **);
 typedef HRESULT (WINAPI *D3D11CreateDevice_Type)(IDXGIAdapter *, D3D_DRIVER_TYPE, HMODULE, UINT, const D3D_FEATURE_LEVEL *, UINT, UINT, ID3D11Device **, D3D_FEATURE_LEVEL *, ID3D11DeviceContext **);
 typedef HRESULT (WINAPI *D3D11CreateDeviceAndSwapChain_Type)(IDXGIAdapter *, D3D_DRIVER_TYPE, HMODULE, UINT, const D3D_FEATURE_LEVEL *, UINT, UINT, const DXGI_SWAP_CHAIN_DESC *, IDXGISwapChain **, ID3D11Device **, D3D_FEATURE_LEVEL *, ID3D11DeviceContext **);
-typedef void	(WINAPI *RSSetViewports_Type)(void *, UINT, D3D11_VIEWPORT *);
+typedef void	(WINAPI *RSSetViewports10_Type)(void *, UINT, D3D10_VIEWPORT *);
+typedef void	(WINAPI *RSSetViewports11_Type)(void *, UINT, D3D11_VIEWPORT *);
 typedef ULONG	(WINAPI *AddRef_Type)(void *);
 typedef ULONG	(WINAPI *Release_Type)(void *);
 typedef HRESULT (WINAPI *Reset_Type)(void *, D3DPRESENT_PARAMETERS*);
@@ -202,7 +228,8 @@ HRESULT WINAPI extD3D10CreateDevice1(IDXGIAdapter *, D3D10_DRIVER_TYPE, HMODULE,
 HRESULT WINAPI extD3D10CreateDeviceAndSwapChain1(IDXGIAdapter *, D3D10_DRIVER_TYPE, HMODULE, UINT, UINT, DXGI_SWAP_CHAIN_DESC *, IDXGISwapChain **, ID3D10Device **);
 HRESULT WINAPI extD3D11CreateDevice(IDXGIAdapter *, D3D_DRIVER_TYPE, HMODULE, UINT, const D3D_FEATURE_LEVEL *, UINT, UINT, ID3D11Device **, D3D_FEATURE_LEVEL *, ID3D11DeviceContext **);
 HRESULT WINAPI extD3D11CreateDeviceAndSwapChain(IDXGIAdapter *, D3D_DRIVER_TYPE, HMODULE, UINT, const D3D_FEATURE_LEVEL *, UINT, UINT, const DXGI_SWAP_CHAIN_DESC *, IDXGISwapChain **, ID3D11Device **, D3D_FEATURE_LEVEL *, ID3D11DeviceContext **);
-void WINAPI extRSSetViewports(ID3D11DeviceContext *, UINT, D3D11_VIEWPORT *);
+void WINAPI extRSSetViewports10(void *, UINT, D3D10_VIEWPORT *);
+void WINAPI extRSSetViewports11(ID3D11DeviceContext *, UINT, D3D11_VIEWPORT *);
 
 extern char *ExplainDDError(DWORD);
 
@@ -243,7 +270,8 @@ D3D10CreateDevice1_Type pD3D10CreateDevice1 = 0;
 D3D10CreateDeviceAndSwapChain1_Type pD3D10CreateDeviceAndSwapChain1 = 0;
 D3D11CreateDevice_Type pD3D11CreateDevice = 0;
 D3D11CreateDeviceAndSwapChain_Type pD3D11CreateDeviceAndSwapChain = 0;
-RSSetViewports_Type pRSSetViewports = 0;
+RSSetViewports10_Type pRSSetViewports10 = 0;
+RSSetViewports11_Type pRSSetViewports11 = 0;
 
 AddRef_Type pAddRef9 = 0;
 Release_Type pRelease9 = 0;
@@ -260,6 +288,7 @@ static HookEntry_Type d3d9Hooks[]={
 	{HOOK_HOT_CANDIDATE, "Direct3DCreate9", (FARPROC)NULL, (FARPROC *)&pDirect3DCreate9, (FARPROC)extDirect3DCreate9},
 	{HOOK_HOT_CANDIDATE, "Direct3DCreate9Ex", (FARPROC)NULL, (FARPROC *)&pDirect3DCreate9Ex, (FARPROC)extDirect3DCreate9Ex},
 	{HOOK_HOT_CANDIDATE, "CheckFullScreen", (FARPROC)NULL, (FARPROC *)&pCheckFullScreen, (FARPROC)extCheckFullScreen},
+	{HOOK_HOT_CANDIDATE, "DisableD3DSpy", (FARPROC)NULL, (FARPROC *)&pDisableD3DSpy, (FARPROC)extDisableD3DSpy},
 	{HOOK_IAT_CANDIDATE, 0, NULL, 0, 0} // terminator
 };
 
@@ -416,6 +445,10 @@ void HookD3DDevice8(void** ppD3Ddev8)
 		SetHook((void *)(**(DWORD **)ppD3Ddev8 + 72), extSetGammaRamp, (void **)&pSetGammaRamp, "SetGammaRamp(D8)");
 		SetHook((void *)(**(DWORD **)ppD3Ddev8 + 76), extGetGammaRamp, (void **)&pGetGammaRamp, "GetGammaRamp(D8)");
 	}
+	if(dxw.dwFlags5 & TEXTUREMASK){
+		SetHook((void *)(**(DWORD **)ppD3Ddev8 + 80), extCreateTexture8, (void **)&pCreateTexture8, "CreateTexture(D8)");
+	//SetHook((void *)(**(DWORD **)ppD3Ddev8 + 112), extCopyRects, (void **)&pCopyRects, "CopyRects(D8)");
+	}
 	SetHook((void *)(**(DWORD **)ppD3Ddev8 + 100), extCreateRenderTarget8, (void **)&pCreateRenderTarget8, "CreateRenderTarget(D8)");
 	SetHook((void *)(**(DWORD **)ppD3Ddev8 + 136), extBeginScene8, (void **)&pBeginScene8, "BeginScene(D8)");
 	SetHook((void *)(**(DWORD **)ppD3Ddev8 + 140), extEndScene8, (void **)&pEndScene8, "EndScene(D8)");
@@ -452,6 +485,9 @@ void HookD3DDevice9(void** ppD3Ddev9)
 		SetHook((void *)(**(DWORD **)ppD3Ddev9 + 84), extSetGammaRamp, (void **)&pSetGammaRamp, "SetGammaRamp(D9)");
 		SetHook((void *)(**(DWORD **)ppD3Ddev9 + 88), extGetGammaRamp, (void **)&pGetGammaRamp, "GetGammaRamp(D9)");
 	}
+	if(dxw.dwFlags5 & TEXTUREMASK){
+		SetHook((void *)(**(DWORD **)ppD3Ddev9 + 92), extCreateTexture9, (void **)&pCreateTexture9, "CreateTexture(D9)");
+	}
 	SetHook((void *)(**(DWORD **)ppD3Ddev9 + 164), extBeginScene9, (void **)&pBeginScene9, "BeginScene(D9)");
 	SetHook((void *)(**(DWORD **)ppD3Ddev9 + 168), extEndScene9, (void **)&pEndScene9, "EndScene(D9)");
 	//SetHook((void *)(**(DWORD **)ppD3Ddev9 +188), extSetViewport, (void **)&pSetViewport, "SetViewport(D9)");
@@ -477,6 +513,21 @@ void HookD3DDevice9(void** ppD3Ddev9)
 
 }
 
+// WIP
+void HookD3DTexture8(void** ppD3Dtex8)
+{
+	OutTraceD3D("Device hook for IDirect3DTexture8 interface\n");
+	SetHook((void *)(**(DWORD **)ppD3Dtex8 + 64), extLockRect, (void **)&pLockRect, "LockRect(D8)");
+	SetHook((void *)(**(DWORD **)ppD3Dtex8 + 68), extUnlockRect8, (void **)&pUnlockRect, "UnlockRect(D8)");
+}
+
+void HookD3DTexture9(void** ppD3Dtex9)
+{
+	OutTraceD3D("Device hook for IDirect3DTexture9 interface\n");
+	SetHook((void *)(**(DWORD **)ppD3Dtex9 + 76), extLockRect, (void **)&pLockRect, "LockRect(D9)");
+	SetHook((void *)(**(DWORD **)ppD3Dtex9 + 80), extUnlockRect9, (void **)&pUnlockRect, "UnlockRect(D9)");
+}
+
 void HookDirect3D8(void *lpd3d)
 {
 	SetHook((void *)(*(DWORD *)lpd3d +  0), extQueryInterfaceD3D8, (void **)&pQueryInterfaceD3D8, "QueryInterface(D8)");
@@ -487,6 +538,12 @@ void HookDirect3D8(void *lpd3d)
 	SetHook((void *)(*(DWORD *)lpd3d + 60), extCreateDevice, (void **)&pCreateDevice8, "CreateDevice(D8)");
 }
 
+BOOL WINAPI extDisableD3DSpy(void)
+{
+	if(TRUE) return FALSE;
+	return (*pDisableD3DSpy)();
+}
+
 void* WINAPI extDirect3DCreate8(UINT sdkversion)
 {
 	void *lpd3d;
@@ -1217,7 +1274,7 @@ HRESULT WINAPI extD3D10CreateDevice(
 	ID3D10Device **ppDevice)
 {
 	HRESULT res;
-	D3D10_VIEWPORT ViewPort;
+	//D3D10_VIEWPORT ViewPort;
 	OutTraceD3D("D3D10CreateDevice: DriverType=%x Flags=%x SDKVersion=%x\n", DriverType, Flags, SDKVersion);
 	//return 0x887a0004;
 	res=(*pD3D10CreateDevice)(pAdapter, DriverType, Software, Flags, SDKVersion, ppDevice);
@@ -1225,17 +1282,20 @@ HRESULT WINAPI extD3D10CreateDevice(
 		OutTraceE("D3D10CreateDevice: ret=%x(%s)\n", res, ExplainDDError(res));
 		return res;
 	}
-	SetHook((void *)(*(DWORD *)*ppDevice + 100), extRSSetViewports, (void **)&pRSSetViewports, "RSSetViewports(D10)");
+	// useless ....
+	//SetHook((void *)(*(DWORD *)*ppDevice + 120), extRSSetViewports10, (void **)&pRSSetViewports10, "RSSetViewports(D10)");
+
+	// useless ....
+	//if(dxw.Windowize){
+	//	ViewPort.TopLeftX=dxw.iPosX;
+	//	ViewPort.TopLeftY=dxw.iPosY;
+	//	ViewPort.Width=dxw.iSizX;
+	//	ViewPort.Height=dxw.iSizY;
+	//	ViewPort.MinDepth=1.0;
+	//	ViewPort.MaxDepth=1.0;
+	//	(*pRSSetViewports10)((void *)*ppDevice, 1, (D3D10_VIEWPORT *)&ViewPort);
+	//}
 
-	if(dxw.Windowize){
-		ViewPort.TopLeftX=dxw.iPosX;
-		ViewPort.TopLeftY=dxw.iPosY;
-		ViewPort.Width=dxw.iSizX;
-		ViewPort.Height=dxw.iSizY;
-		ViewPort.MinDepth=1.0;
-		ViewPort.MaxDepth=1.0;
-		(*pRSSetViewports)((void *)*ppDevice, 1, (D3D11_VIEWPORT *)&ViewPort);
-	}
 	OutTraceD3D("D3D10CreateDevice: ret=%x\n", res);
 	return res;
 }
@@ -1252,7 +1312,7 @@ HRESULT WINAPI extD3D10CreateDevice1(
 	HRESULT res;
 	OutTraceD3D("D3D10CreateDevice1: DriverType=%x Flags=%x HardwareLevel=%x SDKVersion=%x\n", DriverType, Flags, HardwareLevel, SDKVersion);
 	res=(*pD3D10CreateDevice1)(pAdapter, DriverType, Software, Flags, HardwareLevel, SDKVersion, ppDevice);
-	SetHook((void *)(*(DWORD *)*ppDevice + 100), extRSSetViewports, (void **)&pRSSetViewports, "RSSetViewports(D10)");
+	SetHook((void *)(*(DWORD *)*ppDevice + 100), extRSSetViewports10, (void **)&pRSSetViewports10, "RSSetViewports(D10)");
 	OutTraceD3D("D3D10CreateDevice1: ret=%x\n", res);
 	return res;
 }
@@ -1321,7 +1381,7 @@ HRESULT WINAPI extD3D11CreateDevice(
 		OutTraceE("D3D11CreateDevice: ret=%x\n", res);
 		return res;
 	}
-	SetHook((void *)(*(DWORD *)ppImmediateContext + 148), extRSSetViewports, (void **)&pRSSetViewports, "RSSetViewports(D11)");
+	SetHook((void *)(*(DWORD *)ppImmediateContext + 148), extRSSetViewports11, (void **)&pRSSetViewports11, "RSSetViewports(D11)");
 	//SetHook((void *)(*(DWORD *)ppImmediateContext + 152), extRSSetScissorRects, (void **)&pRSSetScissorRects, "RSSetScissorRects(D11)");
 	OutTraceD3D("D3D11CreateDevice ret=%x\n", res);
 	return res;
@@ -1348,7 +1408,7 @@ HRESULT WINAPI extD3D11CreateDeviceAndSwapChain(
 	return res;
 }
 
-void WINAPI extRSSetViewports(ID3D11DeviceContext *This, UINT NumViewports, D3D11_VIEWPORT *pViewports)
+void WINAPI extRSSetViewports10(void *This, UINT NumViewports, D3D10_VIEWPORT *pViewports)
 {
 	OutTraceD3D("RSSetViewports: NumViewports=%d\n", NumViewports);
 
@@ -1359,7 +1419,21 @@ void WINAPI extRSSetViewports(ID3D11DeviceContext *This, UINT NumViewports, D3D1
 		pViewports->Height=dxw.iSizY;
 	}
 
-	(*pRSSetViewports)(This, NumViewports, pViewports);
+	(*pRSSetViewports10)(This, NumViewports, pViewports);
+}
+
+void WINAPI extRSSetViewports11(ID3D11DeviceContext *This, UINT NumViewports, D3D11_VIEWPORT *pViewports)
+{
+	OutTraceD3D("RSSetViewports: NumViewports=%d\n", NumViewports);
+
+	if(dxw.Windowize && (NumViewports==1)){
+		pViewports->TopLeftX=dxw.iPosX;
+		pViewports->TopLeftY=dxw.iPosY;
+		pViewports->Width=dxw.iSizX;
+		pViewports->Height=dxw.iSizY;
+	}
+
+	(*pRSSetViewports11)(This, NumViewports, pViewports);
 }
 
 HRESULT WINAPI extQueryInterfaceD3D8(void *obj, REFIID riid, void** ppvObj)
@@ -1746,3 +1820,91 @@ HRESULT WINAPI extEndStateBlock9(void *lpd3dd, IDirect3DStateBlock9** ppSB)
 	res = (*pEndStateBlock9)(lpd3dd, ppSB);
 	return res;
 }
+
+HRESULT WINAPI extCreateTexture8(void *lpd3dd, UINT Width, UINT Height, UINT Levels, 
+								 DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, 
+								 void **ppTexture)
+{
+	HRESULT res;
+	OutTraceD3D("CreateTexture(8): lpd3dd=%x size=(%dx%d) levels=%d usage=%x format=%d pool=%x\n",
+		lpd3dd, Width, Height, Levels, Usage, Format, Pool);
+	res=(*pCreateTexture8)(lpd3dd, Width, Height, Levels, Usage, Format, Pool, ppTexture);
+	if (res) 
+		OutTraceE("CreateTexture(8) ERROR: err=%x\n", res);
+	else {
+		OutTraceD3D("CreateTexture(8): lpTexture=%x\n", *ppTexture);
+		HookD3DTexture8(ppTexture);
+	}
+	return res;
+}
+
+HRESULT WINAPI extCreateTexture9(void *lpd3dd, UINT Width, UINT Height, UINT Levels, 
+								 DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, 
+								 void **ppTexture, HANDLE *pSharedHandle)
+{
+	HRESULT res;
+	OutTraceD3D("CreateTexture(9): lpd3dd=%x size=(%dx%d) levels=%d usage=%x format=%d pool=%x\n",
+		lpd3dd, Width, Height, Levels, Usage, Format, Pool, ppTexture, pSharedHandle);
+	res=(*pCreateTexture9)(lpd3dd, Width, Height, Levels, Usage, Format, Pool, ppTexture, pSharedHandle);
+	if (res) 
+		OutTraceE("CreateTexture(9) ERROR: err=%x\n", res);
+	else {
+		OutTraceD3D("CreateTexture(9): lpTexture=%x\n", *ppTexture);
+		HookD3DTexture9(ppTexture);
+	}
+	return res;
+}
+BYTE *s;
+int w, h, pitch;
+
+HRESULT WINAPI extLockRect(void *lpd3dtex, UINT Level, D3DLOCKED_RECT *pLockedRect, CONST RECT *pRect, DWORD Flags)
+{
+	HRESULT res;
+	if(IsTraceD3D){
+		char sRect[81];
+		if(pRect) 
+			sprintf_s(sRect, 80, "(%d,%d)-(%d,%d)", pRect->left, pRect->top, pRect->right, pRect->bottom);
+		else 
+			strcpy_s(sRect, 80, "NULL");
+		OutTrace("Texture::LockRect: lpd3dtex=%x level=%d rect=%s flags=%x\n", lpd3dtex, Level, sRect, Flags);
+	}
+	res=(*pLockRect)(lpd3dtex, Level, pLockedRect, pRect, Flags);
+	if (res) OutTraceE("Device::LockRect ERROR: err=%x\n", res);
+	else {
+		OutTraceD3D("Device::LockRect: pBits=%x pitch=%d\n", pLockedRect->pBits, pLockedRect->Pitch);
+	}
+	return res;
+}
+
+typedef void (*TextureHandling_Type)(void *, int);
+
+HRESULT WINAPI extUnlockRect(void *lpd3dtex, UINT Level, TextureHandling_Type TextureHandling)
+{
+	HRESULT res;
+	OutTraceD3D("Texture::UnlockRect: lpd3dtex=%x level=%d\n", lpd3dtex, Level);
+	res=(*pUnlockRect)(lpd3dtex, Level);
+
+	if(TextureHandling) TextureHandling(lpd3dtex, Level);
+	return res;
+}
+
+HRESULT WINAPI extUnlockRect8(void *lpd3dtex, UINT Level)
+{
+	extern void D3D8TextureHandling(void *, int);
+	return extUnlockRect(lpd3dtex, Level, D3D8TextureHandling);
+}
+
+HRESULT WINAPI extUnlockRect9(void *lpd3dtex, UINT Level)
+{
+	extern void D3D9TextureHandling(void *, int);
+	return extUnlockRect(lpd3dtex, Level, D3D9TextureHandling);
+}
+
+HRESULT WINAPI extCopyRects(void *lpd3dd, void *pSourceSurface, CONST RECT *pSourceRectsArray, UINT cRects, void *pDestinationSurface, CONST POINT* pDestPointsArray)
+{
+	HRESULT res;
+	OutTraceD3D("CopyRects: rects=%d\n", cRects);
+	res = (pCopyRects)(lpd3dd, pSourceSurface, pSourceRectsArray, cRects, pDestinationSurface, pDestPointsArray);
+	extern void D3D8TextureHandling(void *, int);
+	//D3D8TextureHandling(pDestinationSurface, 0);
+	return res;}
diff --git a/dll/hd3d8.cpp b/dll/hd3d8.cpp
new file mode 100644
index 0000000..9ec1a06
--- /dev/null
+++ b/dll/hd3d8.cpp
@@ -0,0 +1,68 @@
+#include <D3D8.h>
+#include "dxwnd.h"
+#include "dxwcore.hpp"
+#include "dxhook.h"
+#include "dxhelper.h"
+#include "syslibs.h"
+#include "stdio.h"
+
+extern void TextureHandling(LPDIRECTDRAWSURFACE);
+
+typedef HRESULT (WINAPI *LockRect_Type)(void *, UINT, D3DLOCKED_RECT *, CONST RECT *, DWORD);
+typedef HRESULT (WINAPI *UnlockRect_Type)(void *, UINT);
+
+extern LockRect_Type pLockRect;
+extern UnlockRect_Type pUnlockRect;
+
+extern void D3DTextureDump(D3DSURFACE_DESC, D3DLOCKED_RECT);
+extern void D3DTextureHighlight(D3DSURFACE_DESC, D3DLOCKED_RECT);
+extern void D3DTextureHack(D3DSURFACE_DESC, D3DLOCKED_RECT);
+extern void D3DTextureTransp(D3DSURFACE_DESC, D3DLOCKED_RECT);
+extern char *ExplainD3DSurfaceFormat(DWORD);
+
+void D3D8TextureHandling(void *arg, int Level)
+{
+	HRESULT res;
+	LPDIRECT3DTEXTURE8 lpd3dtex = (LPDIRECT3DTEXTURE8)arg;
+	IDirect3DSurface8 *pSurfaceLevel;
+	D3DSURFACE_DESC Desc;
+	D3DLOCKED_RECT LockedRect;
+	if(res=lpd3dtex->GetSurfaceLevel(Level, &pSurfaceLevel)){
+		OutTraceE("Texture::GetSurfaceLevel ERROR: res=%d(%s)\n", res, ExplainDDError(res));
+		return;
+	}
+	if(res=lpd3dtex->GetLevelDesc(Level, &Desc)){
+		OutTraceE("Texture::GetLevelDesc ERROR: res=%d(%s)\n", res, ExplainDDError(res));
+		return;
+	}
+	pSurfaceLevel->Release();
+	switch(Desc.Type){
+		case D3DRTYPE_SURFACE:
+		case D3DRTYPE_TEXTURE:
+			break;
+		default:
+			return;
+			break;
+	}
+	if(Desc.Usage == D3DUSAGE_RENDERTARGET)return;
+	//pSurfaceLevel->GetRenderTargetData(&pRenderTarget, &pDestSurface);	
+	res=(*pLockRect)(lpd3dtex, Level, &LockedRect, NULL, 0);
+	OutTrace("D3D8TextureHandling: lpd3dtex=%x level=%d format=0x%x(%s) size=(%dx%d) bits=%x pitch=%d\n", 
+		lpd3dtex, Level, Desc.Format, ExplainD3DSurfaceFormat(Desc.Format), 
+		Desc.Width, Desc.Height, LockedRect.pBits, LockedRect.Pitch);
+	switch(dxw.dwFlags5 & TEXTUREMASK){
+		case TEXTUREHIGHLIGHT: 
+			D3DTextureHighlight(Desc, LockedRect);
+			break;
+		case TEXTUREDUMP: 
+			D3DTextureDump(Desc, LockedRect);
+			break;
+		case TEXTUREHACK:
+			D3DTextureHack(Desc, LockedRect);
+			break;
+		case TEXTURETRANSP:
+			D3DTextureTransp(Desc, LockedRect);
+			break;
+	}
+	res=(*pUnlockRect)(lpd3dtex, Level);
+}
diff --git a/dll/hd3d9.cpp b/dll/hd3d9.cpp
new file mode 100644
index 0000000..d239070
--- /dev/null
+++ b/dll/hd3d9.cpp
@@ -0,0 +1,68 @@
+#include <D3D9.h>
+#include "dxwnd.h"
+#include "dxwcore.hpp"
+#include "dxhook.h"
+#include "dxhelper.h"
+#include "syslibs.h"
+#include "stdio.h"
+
+extern void TextureHandling(LPDIRECTDRAWSURFACE);
+
+typedef HRESULT (WINAPI *LockRect_Type)(void *, UINT, D3DLOCKED_RECT *, CONST RECT *, DWORD);
+typedef HRESULT (WINAPI *UnlockRect_Type)(void *, UINT);
+
+extern LockRect_Type pLockRect;
+extern UnlockRect_Type pUnlockRect;
+
+extern void D3DTextureDump(D3DSURFACE_DESC, D3DLOCKED_RECT);
+extern void D3DTextureHighlight(D3DSURFACE_DESC, D3DLOCKED_RECT);
+extern void D3DTextureHack(D3DSURFACE_DESC, D3DLOCKED_RECT);
+extern void D3DTextureTransp(D3DSURFACE_DESC, D3DLOCKED_RECT);
+extern char *ExplainD3DSurfaceFormat(DWORD);
+
+void D3D9TextureHandling(void *arg, int Level)
+{
+	HRESULT res;
+	LPDIRECT3DTEXTURE9 lpd3dtex = (LPDIRECT3DTEXTURE9)arg;
+	IDirect3DSurface9 *pSurfaceLevel;
+	D3DSURFACE_DESC Desc;
+	D3DLOCKED_RECT LockedRect;
+	if(res=lpd3dtex->GetSurfaceLevel(Level, &pSurfaceLevel)){
+		OutTraceE("Texture::GetSurfaceLevel ERROR: res=%d(%s)\n", res, ExplainDDError(res));
+		return;
+	}
+	if(res=lpd3dtex->GetLevelDesc(Level, &Desc)){
+		OutTraceE("Texture::GetLevelDesc ERROR: res=%d(%s)\n", res, ExplainDDError(res));
+		return;
+	}
+	pSurfaceLevel->Release();
+	switch(Desc.Type){
+		case D3DRTYPE_SURFACE:
+		case D3DRTYPE_TEXTURE:
+			break;
+		default:
+			return;
+			break;
+	}
+	if(Desc.Usage == D3DUSAGE_RENDERTARGET)return;
+	//pSurfaceLevel->GetRenderTargetData(&pRenderTarget, &pDestSurface);
+	res=(*pLockRect)(lpd3dtex, Level, &LockedRect, NULL, D3DLOCK_READONLY);
+	OutTrace("D3D9TextureHandling: lpd3dtex=%x level=%d format=0x%x(%s) size=(%dx%d) bits=%x pitch=%d\n", 
+		lpd3dtex, Level, Desc.Format, ExplainD3DSurfaceFormat(Desc.Format), 
+		Desc.Width, Desc.Height, LockedRect.pBits, LockedRect.Pitch);
+	switch(dxw.dwFlags5 & TEXTUREMASK){
+		case TEXTUREHIGHLIGHT: 
+			D3DTextureHighlight(Desc, LockedRect);
+			break;
+		case TEXTUREDUMP: 
+			D3DTextureDump(Desc, LockedRect);
+			break;
+		case TEXTUREHACK:
+			D3DTextureHack(Desc, LockedRect);
+			break;
+		case TEXTURETRANSP:
+			D3DTextureTransp(Desc, LockedRect);
+			break;
+	}
+	res=(*pUnlockRect)(lpd3dtex, Level);
+}
diff --git a/host/dxwndhost.vs2008.suo b/host/dxwndhost.vs2008.suo
index 4b0c3baa7fc33f1e06dfe9b99c735134785ec1a8..47b3c945e964255f6af139f7ba538b944c1b6c64 100644
GIT binary patch
delta 307
zcmZp8!`|?QeM1fl+W~`@8vDgI7qLuYVYOgjU~rk7I7f2w0x>p5)5(o<L?@eZIx(_L
zzR0RP`2nlQWCIp~$p%wdHlN|tVPu@Q`6pL5H**?_o`u&nC!Y{g;Vxh(V#sI60-DIU
z`M+2tBV)<tN(pzX$wsven;n81R3~q$6`FjiB5%5oDWk*YhRP&npy3>o4{-2oepmB?
zak3957my>dss0En>nflrtkV~sWt0c1;c5QTvi(a7V~7{yGPv0GlJksLm>B0H30z{l
zz`;5LsM8Wj@HXQWR>n0*0uLEkIHoUBV|18abb(Q5`>B_Vm27N`tAX0qA*uSn*ux3{
Dd@^dv

delta 306
zcmZp8!`|?QeM1fl+lL#;H}r%z7qLuYVKrc2U~rk7I7f2w0x>p5lgWmh{*xbYaxk(?
zzR0RP`2nlQWCIp~$p%wdHlN|tVPu@P`6pL5H**}ap6QBj85JjA5L01foPKZ$qwps2
z3P#49&6N`FR+F7-8#X%xH>gfNQBg5@K^@0*AyY<&%?*`F%##mr@NE88^Ma9`5$FUU
zn0&WZc~kunR@OB@4(s%VXBp*zcJnlUY1#gzg)zj7aRyv$d&zmmD@=^bkOVF<Uf^Jz
z57fB|N$@t~6;?(|B!P#FEF8=X3^LQ#A7`|lUT}d?Wc#U?jFoI`46A`!*CDC=z}UkI
E0R1UxV*mgE