Сделать скриншот экрана / копировать экранную область видеопамяти

#include <iostream>
#include <stdio.h>
#include <Windows.h>
#include <d3d9.h>
#include <d3dx9tex.h>
 
#pragma comment(lib,"d3dx9.lib")
#pragma comment(lib,"d3d9.lib")
 
 
int main()
{
    IDirect3DDevice9* g_pd3dDevice;
    IDirect3DSurface9* pSurface;
 
    g_pd3dDevice->CreateOffscreenPlainSurface(1920, 1080,
        D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &pSurface, NULL);
    g_pd3dDevice->GetFrontBufferData(0, pSurface);
    D3DXSaveSurfaceToFile(L"Desktop.bmp",D3DXIFF_BMP,pSurface,NULL,NULL);
    pSurface->Release(); 
 
    return 0;
}

#include <iostream>
#include <stdio.h>
#include <Windows.h>
#include <d3d9.h>
#include <d3dx9tex.h>
 
#pragma comment(lib,"d3dx9.lib")
#pragma comment(lib,"d3d9.lib")
 
 
int main()
{
    IDirect3D9 *g_pD3D;
    HWND hWnd;
    
    IDirect3DDevice9 *g_pd3dDevice;
    IDirect3DSurface9 *pSurface;
    D3DDISPLAYMODE d3ddm;
    D3DPRESENT_PARAMETERS d3dpp;
 
    hWnd=GetConsoleWindow();
 
 
    if((g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)) == NULL) {
     printf("fail 1");
    }
    if(FAILED(g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm))) {
    printf("fail 2");
    }
    ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS));
 
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = d3ddm.Format;
    d3dpp.BackBufferHeight = d3ddm.Height;
    d3dpp.BackBufferWidth = d3ddm.Width;
 
 
    if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT,
                               D3DDEVTYPE_HAL, hWnd,
                               D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                               &d3dpp, &g_pd3dDevice))) {
    printf("fail 3");
    }
 
 
    
    if(FAILED(g_pd3dDevice->CreateOffscreenPlainSurface(d3ddm.Width, d3ddm.Height,
        D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &pSurface, NULL)))
    {
        printf("fail 4");
    }
 
    g_pd3dDevice->GetFrontBufferData(0, pSurface);
    D3DXSaveSurfaceToFile(L"Desktop.bmp",D3DXIFF_BMP,pSurface,NULL,NULL);
    pSurface->Release(); 
 
    return 0;
}

void CaptureScreen()
{
    int nScreenWidth = GetSystemMetrics(SM_CXSCREEN);
    int nScreenHeight = GetSystemMetrics(SM_CYSCREEN);
    HWND hDesktopWnd = GetDesktopWindow();
    HDC hDesktopDC = GetDC(hDesktopWnd);
    HDC hCaptureDC = CreateCompatibleDC(hDesktopDC);
    HBITMAP hCaptureBitmap =CreateCompatibleBitmap(hDesktopDC, 
                            nScreenWidth, nScreenHeight);
    SelectObject(hCaptureDC,hCaptureBitmap); 
    BitBlt(hCaptureDC,0,0,nScreenWidth,nScreenHeight,
           hDesktopDC,0,0,SRCCOPY|CAPTUREBLT); 
    SaveCapturedBitmap(hCaptureBitmap); //Place holder - Put your code
                                //here to save the captured image to disk
    ReleaseDC(hDesktopWnd,hDesktopDC);
    DeleteDC(hCaptureDC);
    DeleteObject(hCaptureBitmap);
}

// ...
 
extern void* pBits;
 
#define BITSPERPIXEL 32
 
int main()
{
    IDirect3D9 *g_pD3D;
    HWND hWnd;
    
    IDirect3DDevice9 *g_pd3dDevice;
    IDirect3DSurface9 *pSurface;
    D3DDISPLAYMODE d3ddm;
    D3DPRESENT_PARAMETERS d3dpp;
 
    hWnd = GetConsoleWindow();
 
    if((g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)) == NULL) {
     printf("fail 1");
    }
 
    if(FAILED(g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm))) {
     printf("fail 2");
    }
 
    ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS));
 
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = d3ddm.Format;
    d3dpp.BackBufferHeight = d3ddm.Height;
    d3dpp.BackBufferWidth = d3ddm.Width;
 
    if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT,
                               D3DDEVTYPE_HAL, hWnd,
                               D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                               &d3dpp, &g_pd3dDevice))) {
     printf("fail 3");
    }
 
    if(FAILED(g_pd3dDevice->CreateOffscreenPlainSurface(d3ddm.Width, d3ddm.Height,
        D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &pSurface, NULL)))
    {
        printf("fail 4");
    }
 
    g_pd3dDevice->GetFrontBufferData(0, pSurface);
D3DLOCKED_RECT lockedRect;
pSurface->LockRect(&lockedRect,NULL,
                   D3DLOCK_NO_DIRTY_UPDATE|
                   D3DLOCK_NOSYSLOCK|D3DLOCK_READONLY);
 
for( int i=0 ; i < d3ddm.Height ; i++)
{
    memcpy( (BYTE*) pBits + i * d3ddm.Width * BITSPERPIXEL / 8 , 
        (BYTE*) lockedRect.pBits + i* lockedRect.Pitch , 
        d3ddm.Width * BITSPERPIXEL / 8);
}
 
pSurface->UnlockRect();
pSurface->Release();
 
    return 0;
}

HRESULT InitD3D(HWND hWnd)
{
    D3DPRESENT_PARAMETERS   d3dpp;
 
    if((g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)) == NULL) 
    {
        printf("fail 1");
        return E_FAIL;
    }
    if(FAILED(g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm))) 
    {
        printf("fail 2");
        return E_FAIL;
    }
 
    ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS));
 
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = d3ddm.Format;
    d3dpp.BackBufferHeight = d3ddm.Height;
    d3dpp.BackBufferWidth = d3ddm.Width;
 
 
    if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                               D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                               &d3dpp, &g_pd3dDevice))) 
    {
        printf("fail 3");
        return E_FAIL;
    }
    
    return S_OK;
}
 
HRESULT GetScreenshot()
{
    if(FAILED(g_pd3dDevice->CreateOffscreenPlainSurface(d3ddm.Width, d3ddm.Height,
        D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &pSurface, NULL)))
    {
        printf("fail 4");
        return E_FAIL;
    }
    if(FAILED(g_pd3dDevice->GetFrontBufferData(0, pSurface)))
    {
        printf("fail 5");
        return E_FAIL;
    }
    return S_OK;
}
 
bool GetConstColor(CONSTCOLOR *ConstColor)
{
    D3DSURFACE_DESC     surfaceDesc;  // описание поверхности
    D3DLOCKED_RECT      lockedRect;
    DWORD               *imageData; // указатель на начало памяти поверхности
    int                 index;
    unsigned char r,g,b;
 
    if(FAILED(GetScreenshot())) return false;
 
    pSurface->GetDesc(&surfaceDesc);
    pSurface->LockRect(&lockedRect, 0, 0);
 
    imageData = (DWORD*)lockedRect.pBits;// указатель на начало памяти поверхности
 
    index = ConstColor->y * lockedRect.Pitch/4 + ConstColor->x; //вычисляем координату точки на поверхности
    
    r = (imageData[index]>>16);
    g = (imageData[index]>>8);
    b = imageData[index];
 
    if(r > 255 - accuracy) r = 0xff;
    else r += accuracy;
    if(g > 255 - accuracy) g = 0xff;
    else g += accuracy;
    if(b > 255 - accuracy) b = 0xff;
    else b += accuracy;
 
    ConstColor->imageDataMAX = 0;
    ConstColor->imageDataMAX = (r<<16)|(g<<8)|b;
 
    r = (imageData[index]>>16);
    g = (imageData[index]>>8);
    b = imageData[index];
 
    if(r < accuracy) r = 0;
    else r -= accuracy;
    if(g < accuracy) g = 0;
    else g -= accuracy;
    if(b < accuracy) b = 0;
    else b -= accuracy;
 
    ConstColor->imageDataMIN = 0;
    ConstColor->imageDataMIN = (r<<16)|(g<<8)|b;
 
 
    pSurface->UnlockRect();
    pSurface->Release();
 
    return true;
}

int CaptureBMP(LPCTSTR szFile)
{
    // Source[1]
    HDC hdcScr, hdcMem;
    HBITMAP hbmScr;
    BITMAP bmp;
    int iXRes, iYRes;
 
    // Create a normal DC and a memory DC for the entire screen. The
    // normal DC provides a "snapshot" of the screen contents. The
    // memory DC keeps a copy of this "snapshot" in the associated
    // bitmap.
    hdcScr = CreateDC("DISPLAY", NULL, NULL, NULL);
    hdcMem = CreateCompatibleDC(hdcScr);
 
    iXRes = GetDeviceCaps(hdcScr, HORZRES);
    iYRes = GetDeviceCaps(hdcScr, VERTRES);
 
    // Create a compatible bitmap for hdcScreen.
    hbmScr = CreateCompatibleBitmap(hdcScr, iXRes, iYRes);
    if (hbmScr == 0) return 0;
 
    // Select the bitmaps into the compatible DC.
    if (!SelectObject(hdcMem, hbmScr)) return 0;
 
    // Copy color data for the entire display into a
    // bitmap that is selected into a compatible DC.
    if (!StretchBlt(hdcMem,
        0, 0, iXRes, iYRes,
        hdcScr,
        0, 0, iXRes, iYRes,
        SRCCOPY))
 
        return 0;
 
    // Source[2]
    PBITMAPINFO pbmi;
    WORD cClrBits;
 
    // Retrieve the bitmap's color format, width, and height.
    if (!GetObject(hbmScr, sizeof(BITMAP), (LPSTR) &bmp)) return 0;
 
    // Convert the color format to a count of bits.
    cClrBits = (WORD)(bmp.bmPlanes * bmp.bmBitsPixel);
    if (cClrBits == 1)
        cClrBits = 1;
    else if (cClrBits <= 4)
        cClrBits = 4;
    else if (cClrBits <= 8)
        cClrBits = 8;
    else if (cClrBits <= 16)
        cClrBits = 16;
    else if (cClrBits <= 24)
        cClrBits = 24;
    else cClrBits = 32;
 
    // Allocate memory for the BITMAPINFO structure. (This structure
    // contains a BITMAPINFOHEADER structure and an array of RGBQUAD
    // data structures.)
    if (cClrBits != 24)
        pbmi = (PBITMAPINFO) LocalAlloc(LPTR,
                sizeof(BITMAPINFOHEADER) +
                sizeof(RGBQUAD) * (1 << cClrBits));
 
    // There is no RGBQUAD array for the 24-bit-per-pixel format.
    else
        pbmi = (PBITMAPINFO) LocalAlloc(LPTR,
                sizeof(BITMAPINFOHEADER));
 
    // Initialize the fields in the BITMAPINFO structure.
    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    pbmi->bmiHeader.biWidth = bmp.bmWidth;
    pbmi->bmiHeader.biHeight = bmp.bmHeight;
    pbmi->bmiHeader.biPlanes = bmp.bmPlanes;
    pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel;
    if (cClrBits < 24)
        pbmi->bmiHeader.biClrUsed = (1 << cClrBits);
 
    // If the bitmap is not compressed, set the BI_RGB flag.
    pbmi->bmiHeader.biCompression = BI_RGB;
 
    // Compute the number of bytes in the array of color
    // indices and store the result in biSizeImage.
    pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8
                                    * pbmi->bmiHeader.biHeight * cClrBits;
 
    // Set biClrImportant to 0, indicating that all of the
    // device colors are important.
    pbmi->bmiHeader.biClrImportant = 0;
 
    HANDLE hf;                  // file handle
    BITMAPFILEHEADER hdr;       // bitmap file-header
    PBITMAPINFOHEADER pbih;     // bitmap info-header
    LPBYTE lpBits;              // memory pointer
    DWORD dwTotal;              // total count of bytes
    DWORD cb;                   // incremental count of bytes
    BYTE *hp;                   // byte pointer
    DWORD dwTmp;
 
    pbih = (PBITMAPINFOHEADER) pbmi;
    lpBits = (LPBYTE) GlobalAlloc(GMEM_FIXED, pbih->biSizeImage);
 
    if (!lpBits) return 0;
 
    // Retrieve the color table (RGBQUAD array) and the bits
    // (array of palette indices) from the DIB.
    if (!GetDIBits(hdcMem, hbmScr, 0, (WORD) pbih->biHeight, lpBits, pbmi, DIB_RGB_COLORS)) return 0;
 
    // Create the .BMP file.
    hf = CreateFile(szFile,
                    GENERIC_READ | GENERIC_WRITE,
                    (DWORD) 0,
                    NULL,
                    CREATE_ALWAYS,
                    FILE_ATTRIBUTE_NORMAL,
                    (HANDLE) NULL);
    if (hf == INVALID_HANDLE_VALUE) return 0;
 
    hdr.bfType = 0x4d42;        // 0x42 = "B" 0x4d = "M"
 
    // Compute the size of the entire file.
    hdr.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) +
                 pbih->biSize + pbih->biClrUsed *
                 sizeof(RGBQUAD) + pbih->biSizeImage);
    hdr.bfReserved1 = 0;
    hdr.bfReserved2 = 0;
 
    // Compute the offset to the array of color indices.
    hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) +
                    pbih->biSize + pbih->biClrUsed *
                    sizeof (RGBQUAD);
 
    // Copy the BITMAPFILEHEADER into the .BMP file.
    if (!WriteFile(hf, (LPVOID) &hdr, sizeof(BITMAPFILEHEADER), (LPDWORD) &dwTmp, NULL)) return 0;
 
    // Copy the BITMAPINFOHEADER and RGBQUAD array into the file.
    if (!WriteFile(hf, (LPVOID) pbih, sizeof(BITMAPINFOHEADER)
                + pbih->biClrUsed * sizeof (RGBQUAD),
                (LPDWORD) &dwTmp, NULL))
        return 0;
 
    // Copy the array of color indices into the .BMP file.
    dwTotal = cb = pbih->biSizeImage;
    hp = lpBits;
    if (!WriteFile(hf, (LPSTR) hp, (int) cb, (LPDWORD) &dwTmp, NULL)) return 0;
 
    // Close the .BMP file.
    if (!CloseHandle(hf)) return 0;
 
    // Free memory.
    GlobalFree((HGLOBAL)lpBits);
    ReleaseDC(0, hdcScr);
    ReleaseDC(0, hdcMem);
 
    return 1;
}