游戏修改器制作教程⑨：修改D3D渲染

比眉伴天荒 2022-07-15 04:58 632阅读 0赞

教程面向有C\\C++基础的人，最好还要懂一些Windows编程知识  
代码一律用Visual Studio 2013编译，如果你还在用VC6请趁早丢掉它...  
写这个教程只是为了让玩家更好地体验所爱的单机游戏，顺便学到些逆向知识，我不会用网络游戏做示范，请自重

本章我们要实现hook游戏的渲染过程，把渲染自机换成播放bad apple（只是我看了别人的视频想自己做一个，没什么实际意义，但是可以说明怎么修改指定物体的渲染）

效果如图，压缩GIF后出现了色差请见谅...实际效果没有色差的

![20161102230755682][]

本章源码使用了FFmpeg 3.1.5解码视频，具体看我上一篇文章：[使用FFmpeg+GDI解码和播放视频][FFmpeg_GDI]，在本文使用时记得把FFmpeg的DLL放到游戏目录下（为什么不用DirectShow呢，因为用COM组件在dllmain里会各种死锁崩溃...）

本章使用**东方绀珠传 1.00b 日文版**演示，不保证在其他版本有效...

## 寻找物体特征 ##

有了上一章虚函数表hook的基础我们已经可以hook DrawPrimitive等渲染函数了，但是还无法分辨当前正在渲染什么物体

CE已经提供了解决方案，看到菜单里的D3D了吧，打开游戏进程后把Hook Direct3D勾上，然后打开Snapshot handler

![20161102233934759][]

先改一下设置，我建议把Progressive snapshots勾上，这样更容易看清整个画面渲染过程

![20161102233800188][]

回到游戏后按一下F6，CE会把这帧所有的渲染结果记录下来

![20161102234622217][]

找到渲染目标物体的那张快照，选中它，点Done

可以看出这是通过DrawPrimitiveUP渲染的，还可以浏览渲染时的堆栈，我不是很推荐在这里比较堆栈，因为每次调用渲染函数调用栈都有可能不同，CE的类型识别会错误

![20161102234907231][]

来看看堆栈：

![20161102235209333][]

偏移量为0到40都是CE的D3DHOOK模块的栈，从44开始是游戏程序的部分，偏移量为44的是游戏调用DrawPrimitiveUP返回的地址（因为是004开头的，很容易猜出）

用IDA跳转到那个地址验证一下：

![20161102235807059][]

同理继续往上翻调用栈，然后通过逆向分析寻找有什么可利用的特征

我还是技术不够只能整理出这些，这是角色为灵梦时的调用栈，其他角色还会不同...

471A8D
    主循环，调用渲染
    
    4724CD
    BeginScene、EndScene
    
    401690
    传入this，后面this都是这个，第一个this = [[[0x4E9A54] + 0x40]+0x24]
    对其中一个edi，[edi+8]指向下层函数
    
    4872F2
    push 14，貌似自机特有
    
    487B9C
    esi = [this + 0x1CA01D4 + 14 * 0x608]，不为NULL则push到下一层
    
    4818AE
    switch  ([[this + 0x1CA01D4 + 14 * 0x608] + 0x18] >> 25) & 0x1F
    case    1
    
    47E36E
    设置顶点坐标、SetTexture
    
    47DA73
    SetRenderState
    
    47E499
    SetTextureStageState、SetFVF、DrawPrimitiveUP

经过分析，那个push 14可以利用，看看它在栈里的位置：

![20161103000459987][]

0xE4 - 0x44 = 0xA0，所以我们hook DrawPrimitiveUP后在函数开头获取esp寄存器再加上0xA0就是这个14在栈中的地址了

另外物体特征不限于调用栈里的信息，有时可以用纹理或顶点信息作为特征，本例中没用到

## Hook DrawPrimitiveUP ##

这里用上一章的虚函数表hook

// hook D3D渲染
    		hookVTable(g_pDevice, 83, MyDrawPrimitiveUPWrapper, &RealDrawPrimitiveUP);
    
    // ......
    
    __declspec(naked) // 不让编译器自动加代码破坏栈
    HRESULT STDMETHODCALLTYPE MyDrawPrimitiveUPWrapper(IDirect3DDevice9* thiz, D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride)
    {
    	__asm
    	{
    		pop ecx  // 返回地址出栈
    		push esp // 此时[esp] = thiz
    		push ecx // 恢复返回地址
    		jmp MyDrawPrimitiveUP
    	}
    }
    
    HRESULT STDMETHODCALLTYPE MyDrawPrimitiveUP(DWORD esp, IDirect3DDevice9* thiz, D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride)
    {
    	// 判断是不是在渲染自机
    	if (*(DWORD*)(esp + 0x9C) == 14			// 灵梦
    		|| *(DWORD*)(esp + 0x88) == 14		// 其他角色按住shift
    		)									// 其他情况我就不知道怎么判断了...
    	{
    		// 实现自己的渲染
    	}
    	return RealDrawPrimitiveUP(thiz, PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride);
    }

这里我调试得到的特征只能用于自机角色是灵梦或其他角色按住shift时的情况，技术有限，其他情况我就不知道怎么判断了...  
（东方的渲染做过优化，渲染函数只是向缓冲区里写入数据，直到纹理等渲染状态发生改变时才真正渲染，所以这里的特征有时会失效）

我们要使用内联汇编获取esp寄存器的值，我建议把要用到esp的函数都分为两个部分：

第一个函数MyDrawPrimitiveUPWrapper声明为裸函数防止编译器自动加上push等指令破坏栈，然后用汇编把esp的值作为第一个参数传给MyDrawPrimitiveUP

第二个函数MyDrawPrimitiveUP才是判断正在渲染什么物体，然后实现自己的渲染或直接传给RealDrawPrimitiveUP。因为在第一个函数获取esp之前pop了一次，所以偏移量应该是0xA0 - 4 = 0x9C

## 关于DllMain死锁及视频解码到纹理的问题 ##

DllMain中是不能创建线程的，也不能等待线程结束，不然会造成死锁，但是我的解码器中要创建线程

这里的解决方法是先子类化游戏窗口（相当于hook窗口过程），然后给窗口发送自定义的消息，在主线程处理消息时完成初始化

CDecoder的析构函数中本来要等待线程结束，这里我也改成了直接TerminateThread防止死锁

BOOL APIENTRY DllMain( HMODULE hModule,
                           DWORD  ul_reason_for_call,
                           LPVOID lpReserved
    					 )
    {
    	switch (ul_reason_for_call)
    	{
    	case DLL_PROCESS_ATTACH:
    		// 子类化窗口，拦截窗口消息
    		g_mainWnd = FindWindow(_T("BASE"), _T("搶曽嵁庫揱丂乣 Legacy of Lunatic Kingdom. ver 1.00b")); // 日文编码就是这样...
    		g_realWndProc = (WNDPROC)SetWindowLongPtr(g_mainWnd, GWLP_WNDPROC, (ULONG_PTR)MyWndProc);
    
    		// 接下来的初始化在主线程完成
    		PostMessage(g_mainWnd, WM_DLL_INIT, 0, 0);
    		break;
    
    	case DLL_PROCESS_DETACH:
    		// 恢复D3D hook
    		if (*g_ppDevice != NULL && RealDrawPrimitiveUP != NULL)
    			unhookVTable(g_pDevice, 83, RealDrawPrimitiveUP);
    
    		// 恢复窗口过程
    		if (IsWindow(g_mainWnd))
    			SetWindowLongPtr(g_mainWnd, GWLP_WNDPROC, (ULONG_PTR)g_realWndProc);
    
    		// 释放
    		if (g_decoder != NULL)
    			delete g_decoder;
    		if (g_texture != NULL)
    			g_texture->Release();
    		if (g_frameBuffer != NULL)
    			delete g_frameBuffer;
    		break;
    
    	case DLL_THREAD_ATTACH:
    	case DLL_THREAD_DETACH:
    		break;
    	}
    	return TRUE;
    }
    
    LRESULT CALLBACK MyWndProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
    {
    	if (Msg == WM_DLL_INIT) // 在主线程的初始化
    	{
    		// 初始化FFmpeg解码器
    		av_register_all();
    
    		// 创建解码器
    		g_decoder = new CDecoder("E:\\Bad Apple.avi");
    		g_decoder->SetOnPresent(std::function<void(BYTE*)>(OnPresent));
    
    		// 创建纹理
    		g_decoder->GetVideoSize(g_videoSize);
    		g_frameBuffer = new BYTE[g_videoSize.cx * g_videoSize.cy * 4];
    		D3DDISPLAYMODE dm;
    		g_pDevice->GetDisplayMode(NULL, &dm);
    		g_pDevice->CreateTexture(g_videoSize.cx, g_videoSize.cy, 1, D3DUSAGE_DYNAMIC, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &g_texture, NULL);
    
    		float scale1 = 100.0f / g_videoSize.cx;
    		float scale2 = 100.0f / g_videoSize.cy;
    		float scale = scale1 < scale2 ? scale1 : scale2;
    		g_scaledSize.cx = LONG(g_videoSize.cx * scale1);
    		g_scaledSize.cy = LONG(g_videoSize.cy * scale1);
    
    		// 开始播放
    		g_decoder->Run();
    
    		// hook D3D渲染
    		hookVTable(g_pDevice, 83, MyDrawPrimitiveUPWrapper, &RealDrawPrimitiveUP);
    		return 0;
    	}
    	else if (Msg == WM_UPDATE_TEXTURE) // 更新纹理
    	{
    		// ......
    	}
    
    	return CallWindowProc(g_realWndProc, hWnd, Msg, wParam, lParam);
    }

然后是解码视频的问题，我是在另一个线程解码视频的，而D3D9不是线程安全的，东方好像也没用D3DCREATE\_MULTITHREADED这个flag

所以把解码结果先保存到一个数组，发送消息，在主线程处理消息时再更新纹理

// 把解码出来的RGB数据拷贝到g_frameBuffer
    void OnPresent(BYTE* data)
    {
    	g_frameBufferLock.lock();
    	memcpy(g_frameBuffer, data, g_videoSize.cx * g_videoSize.cy * 4);
    	g_frameBufferLock.unlock();
    	PostMessage(g_mainWnd, WM_UPDATE_TEXTURE, 0, 0);
    }
    
    // ......
    
    	else if (Msg == WM_UPDATE_TEXTURE) // 更新纹理
    	{
    		// D3D9不是线程安全的，这里利用了处理消息时不会渲染
    		D3DLOCKED_RECT rect;
    		g_texture->LockRect(0, &rect, NULL, 0);
    		g_frameBufferLock.lock();
    		for (int y = 0; y < g_videoSize.cy; y++)
    			memcpy((BYTE*)rect.pBits + y * rect.Pitch, g_frameBuffer + y * g_videoSize.cx * 4, g_videoSize.cx * 4);
    		g_frameBufferLock.unlock();
    		g_texture->UnlockRect(0);
    		return 0;
    	}
    
    // ......
    
    // 东方用的顶点结构
    struct THVertex
    {
    	FLOAT    x, y, z;
    	D3DCOLOR specular, diffuse;
    	FLOAT    tu, tv;
    
    	void Set(FLOAT x_, FLOAT y_, FLOAT tu_, FLOAT tv_)
    	{
    		x = x_;
    		y = y_;
    		tu = tu_;
    		tv = tv_;
    	}
    };
    
    // ......
    
    	// 判断是不是在渲染自机
    	if (*(DWORD*)(esp + 0x9C) == 14			// 灵梦
    		|| *(DWORD*)(esp + 0x88) == 14		// 其他角色按住shift
    		)									// 其他情况我就不知道怎么判断了...
    	{
    		// 自己的渲染
    
    		// 设置纹理坐标
    		static THVertex vertex[6];
    		memcpy(vertex, pVertexStreamZeroData, sizeof(vertex));
    		float x = (vertex[0].x + vertex[5].x) / 2, y = (vertex[0].y + vertex[5].y) / 2; // 中点
    		vertex[0].Set(x - g_scaledSize.cx / 2, y - g_scaledSize.cy / 2, 0, 0); // 左上
    		vertex[1].Set(x + g_scaledSize.cx / 2, y - g_scaledSize.cy / 2, 1, 0); // 右上
    		vertex[2].Set(x - g_scaledSize.cx / 2, y + g_scaledSize.cy / 2, 0, 1); // 左下
    		vertex[3].Set(x + g_scaledSize.cx / 2, y - g_scaledSize.cy / 2, 1, 0); // 右上
    		vertex[4].Set(x - g_scaledSize.cx / 2, y + g_scaledSize.cy / 2, 0, 1); // 左下
    		vertex[5].Set(x + g_scaledSize.cx / 2, y + g_scaledSize.cy / 2, 1, 1); // 右下
    
    		// 设置纹理
    		IDirect3DBaseTexture9* oldTexture = NULL;
    		thiz->GetTexture(0, &oldTexture);
    		thiz->SetTexture(0, g_texture);
    
    		// 渲染
    		HRESULT hr = RealDrawPrimitiveUP(thiz, PrimitiveType, PrimitiveCount, vertex, VertexStreamZeroStride);
    
    		// 恢复
    		thiz->SetTexture(0, oldTexture);
    		return hr;
    	}

效果见本文开头的动图

## 更新-较完美的方法 ##

之前我犯傻了，其实只要hook 4872F2那个函数就能知道是不是在渲染自机了，这个方法可以完美用于除了早苗以外的自机，至于早苗...效果很差，我实在不知道怎么办了

另外初始化和更新纹理也用了更加简单的方法，具体自己看代码吧

int __fastcall MyRenderPlayer(void* thiz)
    {
    	g_renderCount = 0;
    	unhook(RenderPlayer, renderPlayerOldCode);
    	int result = RenderPlayer(thiz);
    	hook(RenderPlayer, MyRenderPlayer, renderPlayerOldCode);
    	return result;
    }
    
    HRESULT STDMETHODCALLTYPE MyDrawPrimitiveUP(IDirect3DDevice9* thiz, D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride)
    {
    	if (g_texture == NULL)
    	{
    		// 初始化
    		g_device->CreateTexture(g_videoSize.cx, g_videoSize.cy, 1, D3DUSAGE_DYNAMIC, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &g_texture, NULL);
    	}
    
    	// 判断是不是在渲染自机
    	if (++g_renderCount == 1)
    	{
    		// 自己的渲染
    
    		// 更新纹理
    		if (g_textureNeedUpdate)
    		{
    			D3DLOCKED_RECT rect;
    			g_texture->LockRect(0, &rect, NULL, 0);
    			g_frameBufferLock.lock();
    			for (int y = 0; y < g_videoSize.cy; y++)
    				memcpy((BYTE*)rect.pBits + y * rect.Pitch, g_frameBuffer + y * g_videoSize.cx * 4, g_videoSize.cx * 4);
    			g_textureNeedUpdate = false;
    			g_frameBufferLock.unlock();
    			g_texture->UnlockRect(0);
    		}
    
    		// 设置纹理坐标
    		static THVertex vertex[6];
    		memcpy(vertex, pVertexStreamZeroData, sizeof(vertex));
    		float x = (vertex[0].x + vertex[5].x) / 2, y = (vertex[0].y + vertex[5].y) / 2; // 中点
    		vertex[0].Set(x - g_scaledSize.cx / 2, y - g_scaledSize.cy / 2, 0, 0); // 左上
    		vertex[1].Set(x + g_scaledSize.cx / 2, y - g_scaledSize.cy / 2, 1, 0); // 右上
    		vertex[2].Set(x - g_scaledSize.cx / 2, y + g_scaledSize.cy / 2, 0, 1); // 左下
    		vertex[3].Set(x + g_scaledSize.cx / 2, y - g_scaledSize.cy / 2, 1, 0); // 右上
    		vertex[4].Set(x - g_scaledSize.cx / 2, y + g_scaledSize.cy / 2, 0, 1); // 左下
    		vertex[5].Set(x + g_scaledSize.cx / 2, y + g_scaledSize.cy / 2, 1, 1); // 右下
    
    		// 设置纹理
    		IDirect3DBaseTexture9* oldTexture = NULL;
    		thiz->GetTexture(0, &oldTexture);
    		thiz->SetTexture(0, g_texture);
    
    		// 渲染
    		HRESULT hr = RealDrawPrimitiveUP(thiz, PrimitiveType, PrimitiveCount, vertex, VertexStreamZeroStride);
    
    		// 恢复
    		thiz->SetTexture(0, oldTexture);
    		return hr;
    	}
    
    	return RealDrawPrimitiveUP(thiz, PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride);
    }
    
    // 把解码出来的RGB数据拷贝到g_frameBuffer
    void OnPresent(BYTE* data)
    {
    	g_frameBufferLock.lock();
    	memcpy(g_frameBuffer, data, g_videoSize.cx * g_videoSize.cy * 4);
    	g_textureNeedUpdate = true;
    	g_frameBufferLock.unlock();
    }
    
    DWORD WINAPI initThread(LPVOID)
    {
    	// 初始化FFmpeg解码器
    	av_register_all();
    
    	// 创建解码器
    	g_decoder = new CDecoder("E:\\Bad Apple.avi");
    	g_decoder->SetOnPresent(std::function<void(BYTE*)>(OnPresent));
    
    	// 创建纹理数据缓冲
    	g_decoder->GetVideoSize(g_videoSize);
    	g_frameBuffer = new BYTE[g_videoSize.cx * g_videoSize.cy * 4];
    
    	float scale1 = 100.0f / g_videoSize.cx;
    	float scale2 = 100.0f / g_videoSize.cy;
    	float scale = scale1 < scale2 ? scale1 : scale2;
    	g_scaledSize.cx = LONG(g_videoSize.cx * scale1);
    	g_scaledSize.cy = LONG(g_videoSize.cy * scale1);
    
    	// 开始播放
    	g_decoder->Run();
    
    	// hook
    	hookVTable(g_device, 83, MyDrawPrimitiveUP, (void**)&RealDrawPrimitiveUP);
    	hook(RenderPlayer, MyRenderPlayer, renderPlayerOldCode);
    
    	return 0;
    }
    
    
    BOOL APIENTRY DllMain( HMODULE hModule,
                           DWORD  ul_reason_for_call,
                           LPVOID lpReserved
    					 )
    {
    	switch (ul_reason_for_call)
    	{
    	case DLL_PROCESS_ATTACH:
    		// 在另一个线程初始化，避免死锁
    		CloseHandle(CreateThread(NULL, 0, initThread, NULL, 0, NULL));
    		break;
    
    	case DLL_PROCESS_DETACH:
    		// 恢复hook
    		unhook(RenderPlayer, renderPlayerOldCode);
    		if (g_device != NULL && RealDrawPrimitiveUP != NULL)
    			unhookVTable(g_device, 83, RealDrawPrimitiveUP);
    
    		// 释放
    		if (g_decoder != NULL)
    			delete g_decoder;
    		if (g_texture != NULL)
    			g_texture->Release();
    		if (g_frameBuffer != NULL)
    			delete g_frameBuffer;
    
    		break;
    
    	case DLL_THREAD_ATTACH:
    	case DLL_THREAD_DETACH:
    		break;
    	}
    	return TRUE;
    }

[本章完整源码][Link 1]

## 其他应用 ##

CS这种FPS游戏的透视外挂就是hook了渲染函数然后禁用Z轴缓冲实现的，还有一种方框透视是读取内存中的人物坐标后自己在屏幕上渲染方框

我现在没装CS就用刺客信条看下透视效果吧...

![20161103130817029][]

![20161103130830468][]

[20161102230755682]: /images/20220715/d3d101decf98416ab83b7e5684e879b0.png
[FFmpeg_GDI]: http://blog.csdn.net/xfgryujk/article/details/52986137
[20161102233934759]: /images/20220715/3eacb4e6d80f4411816092ceb57031ec.png
[20161102233800188]: /images/20220715/df82b21d7f0441ad8406acb120a0a9e2.png
[20161102234622217]: /images/20220715/d3a0f2885048425ca1adb4f7f81fd252.png
[20161102234907231]: /images/20220715/5aa8f0ce0c554b6ab9e9e689ce08ea0f.png
[20161102235209333]: /images/20220715/96fc79d58f9d45f9bce30576c9969f4d.png
[20161102235807059]: /images/20220715/e3aa1b50bc1e4eb9969b415679fd8466.png
[20161103000459987]: /images/20220715/097c356936c84677bd524e887225a923.png
[Link 1]: https://github.com/xfgryujk/CheatingTutorial/tree/master/TH15Render
[20161103130817029]: /images/20220715/c4449df1f21246b9b753ffe86ccb3971.png
[20161103130830468]: /images/20220715/b11794b5e22e4443848cb0958dfa6595.png