Drawing to a DirectX game's window.

[pseudorandom21]

So.. I want information on drawing on top of a DirectX game, like how Steam does it. I would consider naively trying to obtain a "device context" of the client area of the game's window, and then try some 2D drawing functions. D: I don't know if that's going to work too well lol.

Enough information to understand what's going on, and what needs to be done is really what I want, thanks.

---
This simple application draws a rectangle on most non-3D programs, but it didn't work with the video games I have tried it on.

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
	auto this_window = GetConsoleWindow();
	cout << "ShowWindow:" << ShowWindow(this_window,SW_HIDE) << endl;

	Sleep(5000);
	auto wnd = GetForegroundWindow();
	auto dc = GetDC(wnd);

	cout << "Rectangle:" << Rectangle(dc,0,0,200,200) << endl;

	cout << "ReleaseDC:" << ReleaseDC(wnd,dc) << endl;
}

[m4ster_r0shi]

It's an interesting topic, so I decided to investigate a bit.

The program you wrote does work with video games.
However, don't forget that in a video game the whole
window is redrawn many times a second. This means
your rectangle is visible merely for some milliseconds.

If you try something like this, you can actually see it:

#include <windows.h>

int main()
{
    HWND wnd;
    HDC dc;

    while (true)
    {
        if (GetAsyncKeyState(VK_ESCAPE) >> 15) break;

        wnd = GetForegroundWindow();
        dc = GetDC(wnd);

        Rectangle(dc, 0, 0, 200, 200);

        ReleaseDC(wnd, dc);

        Sleep(15);
    }
}

But there's a flickering problem, even if you remove the Sleep call.

I googled a bit and discovered the so called layered windows:
http://msdn.microsoft.com/en-us/library/ms997507.aspx

Using info from msdn, I whipped up a small test program:

#define _WIN32_WINNT 0x0500

#include <windows.h>

int main()
{
    HWND hwnd;
    HWND lwnd;
    HDC dc;

    SIZE size;
    POINT ptSrc = {0, 0};
    BLENDFUNCTION blend;

    lwnd = CreateWindowEx(WS_EX_LAYERED | WS_EX_TRANSPARENT |
                          WS_EX_TOOLWINDOW | WS_EX_TOPMOST,
                          0, 0, WS_POPUP | WS_VISIBLE,
                          0, 0, 200, 200, 0, 0, 0, 0);
    size.cx = 200;
    size.cy = 200;

    blend.BlendOp = AC_SRC_OVER;
    blend.BlendFlags = 0;
    blend.AlphaFormat = 0;
    blend.SourceConstantAlpha = 100;

    while (true)
    {
        if (GetAsyncKeyState(VK_ESCAPE) >> 15) break;

        dc = GetDC(lwnd);

        Ellipse(dc, 50, 50, 100, 100);

        ReleaseDC(lwnd,dc);

        hwnd = GetForegroundWindow();

        dc = GetDC(hwnd);

        UpdateLayeredWindow(lwnd, dc, 0, 0, 0, 0, 0, &blend, ULW_OPAQUE);

        ReleaseDC(hwnd,dc);

        Sleep(15);
    }
}

However, the flickering problem is still there...

The fact that the flickering remains even if I remove the Sleep call makes me believe that
this is a synchronization rather than a speed problem. I'm not familiar with the subject,
but I think a better solution would be to intercept the directx API calls somehow (perhaps
using the MS detours library) and draw your stuff right after directx draws its stuff.

[pseudorandom21]

Oh so it does... I'm not interested enough to put much more effort into it, I searched around for a library last night and today, and only found a couple that don't work on W7 64bit. :( bummer

For me the app. doesn't work in full-screen mode on Americas Army 2..