Sorry your browser is not supported!

	IDirect3DDevice9 *screen = dbGetDirect3DDevice();
	screen->GetFrontBufferData(0, (IDirect3DSurface9*)&SrcSurface);

	// First of all grab the image from the screen
	IDirect3DSurface9 *SrcSurface = 0; 
	D3DLOCKED_RECT SrcRect;          
	D3DSURFACE_DESC SrcDesc;

	int wid = dbScreenWidth();
	int hgt = dbScreenHeight();
	int dep = 32; //dbGetBackbufferDepth();

	IDirect3DDevice9 *screen = dbGetDirect3DDevice();
	screen->CreateOffscreenPlainSurface(wid, hgt, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &SrcSurface, NULL);
	screen->GetFrontBufferData(0, SrcSurface);

	SrcSurface->GetDesc(&SrcDesc);
	SrcSurface->LockRect(&SrcRect, 0, 0);

	int pit = SrcRect.Pitch;

	unsigned char *SrcAddr = (unsigned char*)SrcRect.pBits;

	HDC		hScrDC, hMemDC;
	HBITMAP	hBitmap;

	//SrcSurface->GetDC( &hScrDC );
	hScrDC = GetDC( g_pGlob->hWnd );
	hMemDC = CreateCompatibleDC( hScrDC );

	// CreateCompatibleBitmap() just doesn't work at all!
	//hBitmap = CreateCompatibleBitmap(hScrDC, SrcDesc.Width, SrcDesc.Height);
	//SelectObject(hMemDC, hBitmap);

	// TRYING DIB
	BITMAPINFO bmh;
	ZeroMemory(&bmh, sizeof(BITMAPINFO));
	bmh.bmiHeader.biSize			= sizeof(BITMAPINFOHEADER);
	bmh.bmiHeader.biWidth			= wid;
	bmh.bmiHeader.biHeight			= hgt;
	bmh.bmiHeader.biPlanes			= 1;
	bmh.bmiHeader.biBitCount		= 32;
	bmh.bmiHeader.biCompression		= BI_RGB;
	bmh.bmiHeader.biSizeImage		= 0;
	bmh.bmiHeader.biXPelsPerMeter	= 0;
	bmh.bmiHeader.biYPelsPerMeter	= 0;
	bmh.bmiHeader.biClrUsed			= 0;
	bmh.bmiHeader.biClrImportant	= 0;

	void *pbits;
	//char *pbits = new char[wid*hgt*4];
	hBitmap = CreateDIBSection(hMemDC, &bmh, DIB_RGB_COLORS, &pbits, 0, 0);
	//hBitmap = CreateDIBitmap(hMemDC,&bmh.bmiHeader,CBM_INIT,pbits,&bmh,DIB_RGB_COLORS);
	SelectObject( hScrDC, 0);

	BitBlt(hMemDC, 0, 0, SrcDesc.Width, SrcDesc.Height, hScrDC, 0, 0, SRCCOPY);


// GRAB CODE

	DeleteObject( hBitmap );

	SrcSurface->ReleaseDC(hScrDC);
	DeleteDC( hMemDC );

	// release the surface (give it freedom again)
	SrcSurface->UnlockRect();
	SrcSurface->Release();
	SrcSurface=0;

	// delete the buffer now we're done with it
	//delete pbits;

	//BitBlt(hMemDC, 0, 0, wid, hgt, hScrDC, 0, 0, SRCCOPY);
	__asm {
		mov	edx, [pbits]	// destination
		mov	ecx, [SrcAddr]	// source
		mov	eax, [hgt]	// height of bitmap
_lhgt:	        push	eax		// save hgt counter
		push	ecx		// save source address
		mov	ebx, [wid]	// pixel count across
_lwid:	        mov	eax, [ecx]	// grab pixel
		mov	[edx], eax	// store in new bitmap
		add	ecx, 4		// next pixel across
		add	edx, 4
		dec	ebx
		jne	_lwid		// continue until end
		pop	ecx		// restore source address
		add	ecx, [pit]	// add pitch
		pop	eax
		dec	eax
		jne	_lhgt		// next line
	}

IDirect3DSurface9 *        screenGrabSourceSurface;
IDirect3DSurface9 *        screenGrabLockableSurface;

HBITMAP                    screenBitmap;
void *                     screenBitmapData;
int                        screenBitmapScanLineSize;
HDC                        captureDC;

   
if( FAILED(g_pD3DDevice->CreateRenderTarget(pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height, D3DFMT_X8R8G8B8, D3DMULTISAMPLE_NONE, 0,false, &screenGrabSourceSurface, NULL)) )
      return E_UNEXPECTED;

if( FAILED(g_pD3DDevice->CreateOffscreenPlainSurface(pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height, D3DFMT_X8R8G8B8, D3DPOOL_SYSTEMMEM, &screenGrabLockableSurface, NULL)) )
      return E_UNEXPECTED;

IDirect3DDevice9* pd3dDevice = g_pD3DDevice;

IDirect3DSurface9* pRenderTargetSurface = NULL;
if( FAILED(pd3dDevice->GetRenderTarget(0, &pRenderTargetSurface)) )
      { assert( false ); return; }


if( FAILED(pd3dDevice->StretchRect(pRenderTargetSurface, NULL, screenGrabSourceSurface, NULL, D3DTEXF_NONE)) )
      { assert( false ); return; }
SAFE_RELEASE( pRenderTargetSurface );

if( FAILED(pd3dDevice->GetRenderTargetData(screenGrabSourceSurface, screenGrabLockableSurface)) )
      { assert( false ); return; }

     //Create a lock on the DestinationTargetSurface
      D3DLOCKED_RECT lockedRC;
      if( FAILED( screenGrabLockableSurface->LockRect( &lockedRC, NULL, D3DLOCK_NO_DIRTY_UPDATE|D3DLOCK_NOSYSLOCK|D3DLOCK_READONLY ) ) )
      { assert( false ); return 0; }

      LPBYTE lpSource = reinterpret_cast<LPBYTE>(lockedRC.pBits);

      LPBYTE lpDestination = (LPBYTE)screenBitmapData;
      LPBYTE lpDestinationTemp = lpDestination;

      // Copy the data
      lpDestinationTemp += (bbSurfDesc.Height-1) * screenBitmapScanLineSize;
      for ( unsigned int iY = 0; iY < bbSurfDesc.Height; ++iY )
      {
         for ( unsigned int iX = 0; iX < bbSurfDesc.Width; ++iX )
         {
            UINT pixel = ((UINT*)lpSource)[iX];
            lpDestinationTemp[iX*3 + 0] = (BYTE)((pixel >> 0) & 0xFF);
            lpDestinationTemp[iX*3 + 1] = (BYTE)((pixel >> 8) & 0xFF);
            lpDestinationTemp[iX*3 + 2] = (BYTE)((pixel >> 16) & 0xFF);
         }

         lpSource += lockedRC.Pitch;
         lpDestinationTemp -= screenBitmapScanLineSize;
      }


      //Unlock the rectangle
      if( FAILED(screenGrabLockableSurface->UnlockRect()) )
      { assert( false ); return 0; }

   HDC    hdcDesktop = GetDC( GetDesktopWindow() );
   captureDC = CreateCompatibleDC( hdcDesktop );
   ReleaseDC( GetDesktopWindow(), hdcDesktop );

   BITMAPINFO*    pbmpInfo = (BITMAPINFO*)new unsigned char[sizeof( BITMAPINFOHEADER ) + sizeof( unsigned short ) * 256];

   BITMAPINFO& bmpInfo = (*pbmpInfo );
   ZeroMemory(&bmpInfo,sizeof(BITMAPINFO));
   bmpInfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
   bmpInfo.bmiHeader.biBitCount=24;
   bmpInfo.bmiHeader.biCompression = BI_RGB;
   bmpInfo.bmiHeader.biWidth= bbSurfDesc.Width;
   bmpInfo.bmiHeader.biHeight= (int)bbSurfDesc.Height;
   bmpInfo.bmiHeader.biSizeImage = 0;
   bmpInfo.bmiHeader.biPlanes = 1;
   bmpInfo.bmiHeader.biClrUsed = 0;
   bmpInfo.bmiHeader.biClrImportant = 0;

   screenBitmapScanLineSize = (bmpInfo.bmiHeader.biWidth * bmpInfo.bmiHeader.biBitCount + 31) / 32 * 4;

   this->screenBitmap = CreateDIBSection( captureDC, pbmpInfo, DIB_RGB_COLORS, (void**)&screenBitmapData, NULL, NULL );

   delete[] pbmpInfo;

g_pGlob->pHoldBackBufferPtr->GetDevice(&g_pD3DDevice);

{
	HWND DesktopHWND = GetDesktopWindow();
	HDC DesktopDC = GetDC( DesktopHWND );

	RECT WindowRect;
	RECT WindowSize;
	GetWindowRect( g_pGlob->hWnd, &WindowRect );
	GetClientRect( g_pGlob->hWnd, &WindowSize );
	
	HDC MemDC = CreateCompatibleDC( DesktopDC );

	HBITMAP MemBM;
	
	//MemBM = CreateCompatibleBitmap( MemDC, WindowSize.right, WindowSize.bottom );

	BITMAPINFO bmh;
	ZeroMemory(&bmh, sizeof(BITMAPINFO));
	bmh.bmiHeader.biSize			= sizeof(BITMAPINFOHEADER);
	bmh.bmiHeader.biWidth			= WindowSize.right;
	bmh.bmiHeader.biHeight			= WindowSize.bottom;
	bmh.bmiHeader.biPlanes			= 1;
	bmh.bmiHeader.biBitCount		= 32;
	bmh.bmiHeader.biCompression		= BI_RGB;
	bmh.bmiHeader.biSizeImage		= 0;
	bmh.bmiHeader.biXPelsPerMeter	= 1000;
	bmh.bmiHeader.biYPelsPerMeter	= 1000;
	bmh.bmiHeader.biClrUsed			= 0;
	bmh.bmiHeader.biClrImportant	= 0;
	void *pbits;
	MemBM = CreateDIBSection(MemDC, &bmh, DIB_RGB_COLORS, &pbits, 0, 0);

	SelectObject( MemDC, MemBM );

	BitBlt( MemDC, 0, 0, WindowSize.right, WindowSize.bottom, DesktopDC, WindowRect.left, WindowRect.top, SRCCOPY );

//
// GRAB CODE GOES HERE
//

	DeleteObject( MemBM );
	DeleteDC( MemDC );
	ReleaseDC( DesktopHWND, DesktopDC );
}