显卡驱动入手的构造D3DHook的方法

最新推荐文章于 2025-05-21 09:00:03 发布
最新推荐文章于 2025-05-21 09:00:03 发布
阅读量5.2k 收藏 12
点赞数 1
文章标签： d3 显卡
本文介绍了一种通过显卡驱动构造D3DHook的方法，适用于DX9至DX11，无需重启进程。以DX9为例，详细展示了如何Hook OpenAdapter获取pfnCreateDevice，并进一步Hook pfnPresent实现在呈现前自定义绘图。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

转载https://bbs.pediy.com/thread-195759.htm
本文要点：
介绍一种从显卡驱动入手的构造D3DHook的方法,DX9,DX9EX,DX10,DX11均试用,无需重启进程，注入即可使用。

以DX9为例。

前置知识：
1. API Hook的基础知识
2. DX绘图知识
3. 关于DX Hook 有很多种方法，传统的方法请自行查找资料。
4. Windows Display Driver 的基础知识

首先Vender驱动导出了一个叫做OpenAdapter的函数。
原型
1
typedef HRESULT APIENTRY _OpenAdapter(D3DDDIARG_OPENADAPTER
*pAdapterData);
通过观察这个函数的参数可以发现这两个结构体
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
typedef struct _D3DDDIARG_OPENADAPTER
{
    HANDLE                         hAdapter;           // in/out:  Runtime handle/out: Driver handle
    UINT                           Interface;          // in:  Interface version
    UINT                           Version;            // in:  Runtime version
    CONST D3DDDI_ADAPTERCALLBACKS* pAdapterCallbacks;  // in:  Pointer to runtime callbacks
    D3DDDI_ADAPTERFUNCS*           pAdapterFuncs;      // out: Driver function table
    UINT                           DriverVersion;      // out: D3D UMD interface version the
                                                       //      driver was compiled with. Use
                                                       //      D3D_UMD_INTERFACE_VERSION.
} D3DDDIARG_OPENADAPTER;
typedef struct _D3DDDI_ADAPTERFUNCS
{
    PFND3DDDI_GETCAPS                       pfnGetCaps;
    PFND3DDDI_CREATEDEVICE                  pfnCreateDevice;
    PFND3DDDI_CLOSEADAPTER                  pfnCloseAdapter;
} D3DDDI_ADAPTERFUNCS;

HookOpenAdapter代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
BOOL DetourOpenAdapter()
{
OpenAdapter = (_OpenAdapter *)GetProcAddress(GetModuleHandleA("nvd3dum.dll"), "OpenAdapter");
if (OpenAdapter == NULL)
{
OpenAdapter = (_OpenAdapter *)GetProcAddress(GetModuleHandleA("aticfx32.dll"), "OpenAdapter");
}
 
if (OpenAdapter)
{
DetourRestoreAfterWith();
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach((void **)&OpenAdapter, WarpOpenAdapter);
DetourTransactionCommit();
}
 
return OpenAdapter != NULL;
}

通过Hook OpenAdapter 可以得到pfnCreateDevice;
代码如下
1
2
3
4
5
6
7
8
9
10
HRESULT APIENTRY WarpOpenAdapter(D3DDDIARG_OPENADAPTER *pAdapterData)
{
    HRESULT ret = OpenAdapter(pAdapterData);
    if (ret == S_OK && pAdapterData->pAdapterFuncs->pfnCreateDevice)
    {
        DdiCreateDevice = pAdapterData->pAdapterFuncs->pfnCreateDevice;
        pAdapterData->pAdapterFuncs->pfnCreateDevice = WarpDdiCreateDevice;
    }
    return ret;
}
pfnCreateDevice是Vender驱动上报给runtime的createDevice API.当APP调用CreateDevice最后会到厂商驱动的pfnCreateDevice; 替换厂商驱动上报给runtime的pfnCreateDevice函数指针,就可以实现Hook pfnCreateDevice。这样下次APP调用CreateDevice就会先进入我们的WarpDdiCreateDevice;
代码如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
HRESULT APIENTRY WarpDdiCreateDevice(
    HANDLE hAdapter,
    D3DDDIARG_CREATEDEVICE *pDeviceData)
{
    // DdiCreateDevice must not be NULL if this path hit
    HRESULT ret = DdiCreateDevice(hAdapter, pDeviceData);
    if (pDeviceData->pDeviceFuncs->pfnPresent && gDetourFuncTable.DdiPresent.isAttatched == FALSE)
    {
        DdiPresent = pDeviceData->pDeviceFuncs->pfnPresent;
        ULONG_PTR realTramponLine = DetourDDiPresent();
        gDetourFuncTable.DdiPresent.isAttatched = TRUE;
        gDetourFuncTable.DdiPresent.preFuncPtr = DdiPresent;
        gDetourFuncTable.DdiPresent.TrampoLinePtr = (PFND3DDDI_PRESENT)realTramponLine;
        gDetourFuncTable.DdiPresent.warpFuncPtr = WarpDdiPresent;
    }
    if (pDeviceData->pDeviceFuncs->pfnPresent1 && gDetourFuncTable.DdiPresent1.isAttatched == FALSE)
    {
        DdiPresent1 = pDeviceData->pDeviceFuncs->pfnPresent1;
        ULONG_PTR realTramponLine = DetourDDiPresent1();
        gDetourFuncTable.DdiPresent1.isAttatched = TRUE;
        gDetourFuncTable.DdiPresent1.preFuncPtr = DdiPresent1;
        gDetourFuncTable.DdiPresent1.TrampoLinePtr = (PFND3DDDI_PRESENT1)realTramponLine;
        gDetourFuncTable.DdiPresent1.warpFuncPtr = WarpDdiPresent1;
    }
    DdiLock = pDeviceData->pDeviceFuncs->pfnLock;
    DdiCreateResource = pDeviceData->pDeviceFuncs->pfnCreateResource;
    DdiCreateResource2 = pDeviceData->pDeviceFuncs->pfnCreateResource2;
    DdiUnlock = pDeviceData->pDeviceFuncs->pfnUnlock;
    DdiBlt = pDeviceData->pDeviceFuncs->pfnBlt;
 
    return ret;
}
 
typedef struct _D3DDDIARG_CREATEDEVICE
{
    HANDLE                          hDevice;                // in:  Runtime handle/out: Driver handle
    UINT                            Interface;              // in:  Interface version
    UINT                            Version;                // in:  Runtime Version
    CONST D3DDDI_DEVICECALLBACKS*   pCallbacks;             // in:  Pointer to runtime callbacks
    VOID*                           pCommandBuffer;         // in:  Pointer to the first command buffer to use.
    UINT                            CommandBufferSize;      // in:  Size of the first command buffer to use.
    D3DDDI_ALLOCATIONLIST*          pAllocationList;        // out: Pointer to the first allocation list to use.
    UINT                            AllocationListSize;     // in:  Size of the allocation list that will be available
                                                            //      when the first command buffer is submitted.
    D3DDDI_PATCHLOCATIONLIST*       pPatchLocationList;     // out: Pointer to the first patch location list to use.
    UINT                            PatchLocationListSize;  // in:  Size of the patch location list that will be available
                                                            //      when the first command buffer is submitted.
    D3DDDI_DEVICEFUNCS*             pDeviceFuncs;           // out: Driver function table
    D3DDDI_CREATEDEVICEFLAGS        Flags;                  // in:  Flags
#if (D3D_UMD_INTERFACE_VERSION >= D3D_UMD_INTERFACE_VERSION_WIN7)
    D3DGPU_VIRTUAL_ADDRESS          CommandBuffer;          // out: GPU Virtual address to the command buffer to use. _ADVSCH_
#endif // D3D_UMD_INTERFACE_VERSION
} D3DDDIARG_CREATEDEVICE;
观察参数D3DDDIARG_CREATEDEVICE *pDeviceData不难发现 pDeviceFuncs中有我们需要的一切绘图API,这里用到的函数如下:
1
2
3
4
5
6
7
8
PFND3DDDI_CREATEDEVICE DdiCreateDevice = NULL;
PFND3DDDI_PRESENT DdiPresent = NULL;
PFND3DDDI_PRESENT1 DdiPresent1= NULL;
PFND3DDDI_LOCK DdiLock = NULL;
PFND3DDDI_CREATERESOURCE DdiCreateResource = NULL;
PFND3DDDI_CREATERESOURCE2 DdiCreateResource2 = NULL;
PFND3DDDI_UNLOCK DdiUnlock = NULL;
PFND3DDDI_BLT DdiBlt = NULL;
代码如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
HRESULT APIENTRY WarpDdiCreateDevice(
    HANDLE hAdapter,
    D3DDDIARG_CREATEDEVICE *pDeviceData)
{
    // DdiCreateDevice must not be NULL if this path hit
    HRESULT ret = DdiCreateDevice(hAdapter, pDeviceData);
    if (pDeviceData->pDeviceFuncs->pfnPresent && gDetourFuncTable.DdiPresent.isAttatched == FALSE)
    {
        DdiPresent = pDeviceData->pDeviceFuncs->pfnPresent;
        ULONG_PTR realTramponLine = DetourDDiPresent();
        gDetourFuncTable.DdiPresent.isAttatched = TRUE;
        gDetourFuncTable.DdiPresent.preFuncPtr = DdiPresent;
        gDetourFuncTable.DdiPresent.TrampoLinePtr = (PFND3DDDI_PRESENT)realTramponLine;
        gDetourFuncTable.DdiPresent.warpFuncPtr = WarpDdiPresent;
    }
    if (pDeviceData->pDeviceFuncs->pfnPresent1 && gDetourFuncTable.DdiPresent1.isAttatched == FALSE)
    {
        DdiPresent1 = pDeviceData->pDeviceFuncs->pfnPresent1;
        ULONG_PTR realTramponLine = DetourDDiPresent1();
        gDetourFuncTable.DdiPresent1.isAttatched = TRUE;
        gDetourFuncTable.DdiPresent1.preFuncPtr = DdiPresent1;
        gDetourFuncTable.DdiPresent1.TrampoLinePtr = (PFND3DDDI_PRESENT1)realTramponLine;
        gDetourFuncTable.DdiPresent1.warpFuncPtr = WarpDdiPresent1;
    }
    DdiLock = pDeviceData->pDeviceFuncs->pfnLock;
    DdiCreateResource = pDeviceData->pDeviceFuncs->pfnCreateResource;
    DdiCreateResource2 = pDeviceData->pDeviceFuncs->pfnCreateResource2;
    DdiUnlock = pDeviceData->pDeviceFuncs->pfnUnlock;
    DdiBlt = pDeviceData->pDeviceFuncs->pfnBlt;
 
    return ret;
}
到这里我们已经顺利拿到厂商的pfnPresent函数了,是不是有点兴奋呢？因为我们要做的任何绘图工作需要在pfnPresent之前完成。这样present才会把我们画的东西拷贝到屏幕上。
或许你会有一个疑问，APP已经在运行了，不会再调用CreateDevice了，这样我们的Hook不就无效了吗？
答案是这样的，既然APP调用CreateDevice,那我们就自己调用。我们来构造这样一个CreateDevice的条件，创建出来的d3dDevice还能在后面用来作为我们绘图的设备(OnRenderFrame).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
BOOL TryInitD3D(HWND hWnd)
{
 
    D3DPRESENT_PARAMETERS d3dpp;
    HRESULT hResult = D3DERR_INVALIDCALL;
 
    ZeroMemory(&d3dpp, sizeof(d3dpp));
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
 
    pd3dInternal = Direct3DCreate9(D3D_SDK_VERSION);
    if (pd3dInternal != NULL)
    {
        hResult = pd3dInternal->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
            D3DCREATE_SOFTWARE_VERTEXPROCESSING,
            &d3dpp, &pd3dDevInternal);
    }
 
    return hResult == S_OK && pd3dDevInternal != NULL && InitDx();
}
拿到pfnPresent之后做inlineHook
1
2
3
4
5
6
7
8
9
10
11
12
13
14
ULONG_PTR DetourDDiPresent1()
{
    ULONG_PTR realTrampoLine = NULL;
 
    DetourRestoreAfterWith();
    DetourTransactionBegin();
    DetourUpdateThread(GetCurrentThread());
    if (DdiPresent1)
    {
        DetourAttachEx((void **)&DdiPresent1, WarpDdiPresent1, (PDETOUR_TRAMPOLINE *)&realTrampoLine, NULL, NULL);
    }
    DetourTransactionCommit();
    return realTrampoLine;
}
然后在pfnPrsent的代理函数中做我们自己的绘图操作。里面涉及的函数下面会有解释
我实现了一个简单的pfnPresent1代理函数,在里面调用真正的pfnPresent1之前做我们的绘图（我是的WIN 8.1,WDDM1.3 所以就对pfnPresent1动手了）
代理函数如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
HRESULT APIENTRY WarpDdiPresent1(
    HANDLE hDevice,
    CONST D3DDDIARG_PRESENT1 *pPresent1)
{
    static HANDLE wrapDevice = NULL;
    static HANDLE hDestSurf = NULL;
    static UINT cachedWidth = 0;
    static UINT cachedHeight = 0;
    RECT rc = { 0 };
    RECT destRC = { 0 };
    RECT srcRC = { 0 };
    IDirect3DSurface9 * pSrcSurf = NULL;
    HRESULT hRet = S_OK;
 
        //如果是运行中的app画图，就进入下面的流程进行我们的画图
        //反之是我们的画图操作，直接放过，避免重入
    if (hDevice == wrapDevice || wrapDevice == NULL)
    {
        wrapDevice = hDevice;
        if (S_OK == onRenderFrame(&pSrcSurf, &rc))
        {
            if (rc.right - rc.left != cachedWidth ||
                rc.bottom - rc.top != cachedHeight)
            {
                cachedWidth = rc.right - rc.left;
                cachedHeight = rc.bottom - rc.top;
 
                //TODO: destroy hDestSurf
                hDestSurf = CreateSurfaceforWDDM1_3(hDevice, cachedWidth, cachedHeight);
            }
 
            if (hDestSurf != NULL)
            {
                destRC = srcRC = rc;
                hRet = SurfaceBltInternal(hDevice, hDestSurf, destRC, pSrcSurf, srcRC);
            }
 
            if (hRet == S_OK)
            {
                BltToRTWDDM1_3(hDevice, hDestSurf, pPresent1,rc);
            }
        }
 
    }
    hRet = gDetourFuncTable.DdiPresent1.TrampoLinePtr(hDevice, pPresent1);
    return hRet;
}
HRESULT APIENTRY onRenderFrame(__out IDirect3DSurface9 ** pOutSurf, RECT * pOutRC)是我们的绘图函数，在这里实现我们要的东西，画到RenderTarget上，然后输出RenderTarget和它的大小。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
HRESULT APIENTRY onRenderFrame(__out IDirect3DSurface9 ** pOutSurf, RECT * pOutRC)
{
    HRESULT hr;
    RECT rc;
 
    pd3dDev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_RGBA(0, 0, 0, 0), 1.0f, 0);
    if (S_OK == pd3dDev->BeginScene())
    {
        hr = pd3dDev->SetRenderTarget(NULL, pRTSurf);
        //在这里画你需要的任何东西，没错 就是这么任性。
        pd3dDev->EndScene();
    }
 
    if (hr == S_OK)
    {
        *pOutSurf = pRTSurf;
        *pOutRC = rc;
    }
    else
    {
        *pOutSurf = NULL;
        pOutRC->top = 0;
        pOutRC->left = 0;
        pOutRC->bottom = 0;
        pOutRC->right = 0;
    }
 
    return hr;
}
当在WarpDdiPresent1得到我们的绘图结果（RenderTarget和大小）之后，我们就能把画好的结果拿出来，然后通过调用厂商提供的pfnBlt函数 贴到present的SrcSurf上。

//用上面拿到的pfnCreateResource2 创建一张surface 用来保存我们的绘图结果。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
HANDLE CreateSurfaceforWDDM1_3(HANDLE hDevice, UINT width, UINT height)
{
    D3DDDIARG_CREATERESOURCE2 createResourceData2;
    D3DDDI_SURFACEINFO surfList[1];
 
    memset(surfList, 0, sizeof(surfList));
    memset(&createResourceData2, 0, sizeof(createResourceData2));
 
    surfList[0].Height = width;
    surfList[0].Width = height;
    surfList[0].Depth = 1;
    surfList[0].pSysMem = NULL;
    surfList[0].SysMemPitch = 0;
    surfList[0].SysMemSlicePitch = 0;
 
    createResourceData2.Format = D3DDDIFMT_A8R8G8B8;
    createResourceData2.Pool = D3DDDIPOOL_NONLOCALVIDMEM;
    createResourceData2.MultisampleType = D3DDDIMULTISAMPLE_NONE;
    createResourceData2.MultisampleQuality = 0;
    createResourceData2.pSurfList = surfList;
    createResourceData2.SurfCount = 1;
    createResourceData2.MipLevels = 0;
    createResourceData2.Fvf = 0;
    createResourceData2.VidPnSourceId = 0;
    createResourceData2.RefreshRate.Denominator = 0;
    createResourceData2.RefreshRate.Numerator = 0;
    // use a particular handle that runtime do not use
    createResourceData2.hResource = (HANDLE)0xfff00000;
    createResourceData2.Flags.Value = 0;
    createResourceData2.Rotation = D3DDDI_ROTATION_IDENTITY;
 
    DdiCreateResource2(hDevice, &createResourceData2);
 
    return createResourceData2.hResource;
}
//把OnRenderFrame输出的RenderTarget的内容拷贝到创建的Surface
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
HRESULT SurfaceBltInternal(HANDLE hDevice, HANDLE hDestSurf, RECT destSurfRC, IDirect3DSurface9 * pSrcSurf, RECT srcSurfRC)
{
    D3DDDIARG_LOCK lockdata;
    D3DDDIARG_UNLOCK unlockData;
    D3DLOCKED_RECT lockedRC;
    HRESULT hr;
 
    if (destSurfRC.right - destSurfRC.left < srcSurfRC.right - srcSurfRC.left ||
        destSurfRC.bottom - destSurfRC.top < srcSurfRC.bottom - srcSurfRC.top)
    {
        hr = S_FALSE;
    }
    else
    {
        memset(&lockdata, 0, sizeof(lockdata));
        memset(&unlockData, 0, sizeof(unlockData));
 
        lockdata.hResource = hDestSurf;
        lockdata.SubResourceIndex = 0;
        lockdata.Area.left = 0;
        lockdata.Area.right = destSurfRC.right - destSurfRC.left;
        lockdata.Area.top = 0;
        lockdata.Area.bottom = destSurfRC.bottom - destSurfRC.top;
 
        hr = DdiLock(hDevice, &lockdata);
        if (hr == S_OK)
        {
            hr = pSrcSurf->LockRect(&lockedRC, &srcSurfRC, NULL);
            if (S_OK == hr)
            {
                CHAR *pDest = (CHAR*)lockdata.pSurfData;
                CHAR *pSrc = (CHAR*)lockedRC.pBits;
                for (UINT i = 0; i < destSurfRC.bottom - destSurfRC.top; i++)
                {
 
                    CopyMemory(pDest, pSrc, lockedRC.Pitch < lockdata.Pitch ? lockedRC.Pitch : lockdata.Pitch);
                    pDest += lockdata.Pitch;
                    pSrc += lockedRC.Pitch;
                }
 
            }
            pSrcSurf->UnlockRect();
            memset(&unlockData, 0, sizeof(unlockData));
            unlockData.hResource = hDestSurf;
            unlockData.SubResourceIndex = 0;
            DdiUnlock(hDevice, &unlockData);
        }
    }
    return hr;
}
//调用厂商提供的pfnBLT把surafce上保存的图画 搬到 present的SrcSurf中，这样 present的时候 我们画的东西就展现出来了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
HRESULT BltToRTWDDM1_1(HANDLE hDevice, HANDLE hRes, CONST D3DDDIARG_PRESENT *pPresent)
{
    D3DDDIARG_BLT bltData;
    RECT srcRC;
    RECT destRC;
 
    memset(&bltData, 0, sizeof(bltData));
    memset(&srcRC, 0, sizeof(srcRC));
    memset(&destRC, 0, sizeof(destRC));
     
    srcRC.left = 0;
    srcRC.top = 0;
    srcRC.right = 200;
    srcRC.bottom = 200;
 
    destRC.left = 0;
    destRC.top = 0;
    destRC.right = 200;
    destRC.bottom = 200;
 
    bltData.hDstResource = pPresent->hSrcResource;
    bltData.DstSubResourceIndex = pPresent->SrcSubResourceIndex;
    bltData.hSrcResource = hRes;
    bltData.SrcSubResourceIndex = 0;
    bltData.SrcRect = srcRC;
    bltData.DstRect = destRC;
 
    return DdiBlt(hDevice, &bltData);
}
如有错误之处，还请各位指正。欢迎各位大牛小牛牛牛拍砖了。
YuHengZuo
关注
游戏修改器制作教程八：D3D函数hook
El Psy Congroo
10-06 1万+
本章介绍怎么hook D3D函数，实现在游戏画面中显示自己的文字
【游戏逆向】D3D HOOK实现透视讲解
douluo998的博客
07-02 1681
在消隐时，Direct3D先用背景色（或纹理）填充渲染表面，Z缓存则统一设置成最大深度，即投影变换中后裁剪平面的距离，然后逐像素处理渲染表面：对于任意一个像素，Direct3D逐一测试所有与该像素重叠的三角形，如果三角形中像素对应点的Z坐标小于Z缓存中的数值，也就是说，此三角形离观察者较近，则像素取该点的颜色，同时像素在Z缓存中的深度也设为该点的Z坐标，然后继续测试下一个三角形…这些图元分为点列，线列，线带，三角形列，三角形带，三角扇形。顶点缓存通常除顶点坐标之外还包括法线，颜色，纹理等数据。
HOOK graphics driver_.zip_d3d_d3d驱动hook_显卡D3D_显卡驱动_驱动源码
07-15
hook d3d显卡驱动源码,内核驱动hook
D3D函数hook
laikaikai的博客
05-11 3633
目前讲的内容已经足够制作大部分游戏的修改器了，主要看你对API的熟悉程度和逆向调试的经验再深入讲的话就是系统内核层了，比如SSDT hook什么的，而一般单机游戏不会用到内核层的保护（但是大部分网游会），而且调试和修改内核层的东西比较麻烦，很容易蓝屏，所以不打算讲内核的东西本章介绍怎么hook D3D函数，实现在游戏画面中显示自己的文字，阅读之前最好补习下D3D编程的知识，本章以D3D9、32位程...
GH_D3D11_Hook：轻松掌握DirectX 11图形渲染
最新发布
gitblog_00899的博客
05-21 309
GH_D3D11_Hook：轻松掌握DirectX 11图形渲染 项目介绍 GH_D3D11_Hook 是一个基于 DirectX 11 的简单图形渲染钩子（hook）项目。它允许开发者和技术爱好者拦截并修改 3D 图形应用程序中的渲染流程，比如游戏。这个开源项目专为 x86/x64 架构设计，以提供广泛的兼容性。GH_D3D11_Hook 通过注入一个 DLL 文件到游戏进程中，实现在 Dire...
D3Dhook通杀通杀所有DirectX版本_D3Dhook通杀所有DirectX版本_d3dhook_
09-29
D3D hook通杀所有系统win xp -win 8.1 通杀所有DirectX版本
D3D Hook示例源码
12-03
以当下某款热门游戏为例，通过Hook D3D函数，实现透视等功能。
D3dHook.rar_D3Dhook C++_HookD3Ddll_XW1_c# hook d3d_d3dhook插件
07-15
标题中的"D3dHook.rar"表明这是一个关于Direct3D钩子（D3D Hook）的资源，其中包含了一个名为"D3dHook.dll"的动态链接库文件。D3Dhook是一个用于修改或拦截Direct3D图形接口的工具，通常由程序员使用以实现特定的...
易语言D3DHook 模块源码含例子-易语言
06-12
在本压缩包中，我们关注的是“D3DHook”模块，这是一段用于图形处理，特别是DirectX相关的源码，包含了一些示例代码。以下是关于这个主题的详细知识点： 1. **DirectX**: DirectX是微软开发的一套应用程序接口（API...
易语言D3DHook
07-15
易语言D3DHook源码,D3DHook,初始化设备,初始化顶点缓冲,渲染,转,配置矩阵,hook,NewDirect3DCreate9,NewCreateDevice,NewPresent,安装ApiHook,开始Hook,停止Hook,卸载ApiHook,取Hook信息,Jmp,取指针内容_整数,GetAdd,...
易语言D3DHOOK方框透视课程视频课程下载整理.zip
08-21
同时，课程会详细介绍D3DHOOK技术，这是一种通过拦截和修改图形渲染过程中的数据来实现特殊视觉效果的方法，比如在游戏中看到通常被遮挡的物体。 透视在图形学中是一个关键的概念，它涉及到我们如何在二维屏幕上...
d3d hook模块
07-29
d3d hook 可以对d3d游戏进行写屏 支持dx8 dx9
窗口化D3dHook
10-11
窗口化工具.窗口化工具.窗口化工具.窗口化工具.窗口化工具.窗口化工具.窗口化工具.
纯源码 D3DHOOK绘制例子 简单易懂-易语言
06-14
纯源码 D3DHOOK绘制例子 简单易懂 逻辑清晰 适合学习D3DHOOK的朋友 相关的函数可以自行扩展 达到自己想要的效果 游戏里面也可以使用,Z缓冲可以达到穿透模型遮挡 另外附上CSGO注入代码( 某些程序HOOK了一些函数导致无法注入,我这里给出一个解决办法 ) 部分代码借鉴前辈,大牛勿喷. 如果对你有用,请给个好评呗 木木哒
【C++】D3D11 最新HOOK 源码支持X86_X64
05-21
【C++】D3D11 最新HOOK 源码支持X86_X64 【C++】D3D11 最新HOOK 源码支持X86_X64 【C++】D3D11 最新HOOK 源码支持X86_X64 【C++】D3D11 最新HOOK 源码支持X86_X64 【C++】D3D11 最新HOOK 源码支持X86_X64 【C++】D3D11 最新HOOK 源码支持X86_X64 【C++】D3D11 最新HOOK 源码支持X86_X64 【C++】D3D11 最新HOOK 源码支持X86_X64 【C++】D3D11 最新HOOK 源码支持X86_X64 【C++】D3D11 最新HOOK 源码支持X86_X64 【C++】D3D11 最新HOOK 源码支持X86_X64 【C++】D3D11 最新HOOK 源码支持X86_X64
D3DHook.rar
04-04
D3DHook.rar
D3D HOOK实现透视讲解
qq13197107741的博客
06-06 3751
实现目的： 目前大部分游戏通过Direct3D实现3D效果，通过挂钩相应函数，可以实现3D透视，屏幕挂字效果。而透视，屏蔽特定效果，设置透明在很多游戏（特别是FPS）中发挥着巨大的作用！ 实现思路： [D3D] DirectX的功能都是以COM组件的形式提供的。在Direct3D中，主要通过采取以下操作来实现编程： 调用适当的函数获取接口指针； 调用接口的方法（成员函数）来完成所需功能； 用完接口后，调用Release方法进行“释放”，注意释放顺序应该和获取它们的顺序相反。 D3D的实现流程： 大体可以分为
HOOK显卡驱动达到D3D游戏，c++实现人物透视完美源代码！
05-17 8076
好久没发过贴了，前段时间无聊写的个D3D透视，也用过没什么问题， 我对玩游戏都是三分钟热度，玩一盘就没兴趣了！今天无聊上开透视发现被和谐了 所以放出来给大家做个参考吧！ 注：源码不是最新的，不过大家根据里面的汇编定位就可以更新了 第一种： 我利用的是在进入D3D透视地址之前hook ，需要说的是现在这种方法被检测了，Hook会出现非法模块！ 我不知道是我注入的问题还是啥问题！...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值