RageSurface* RageDisplay_D3D::CreateScreenshot() { #if defined(XBOX) return NULL; #else RageSurface * result = NULL; // Get the back buffer. IDirect3DSurface9* pSurface; if( SUCCEEDED( g_pd3dDevice->GetBackBuffer( 0, 0, D3DBACKBUFFER_TYPE_MONO, &pSurface ) ) ) { // Get the back buffer description. D3DSURFACE_DESC desc; pSurface->GetDesc( &desc ); // Copy the back buffer into a surface of a type we support. IDirect3DSurface9* pCopy; if( SUCCEEDED( g_pd3dDevice->CreateOffscreenPlainSurface( desc.Width, desc.Height, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &pCopy, NULL ) ) ) { if( SUCCEEDED( D3DXLoadSurfaceFromSurface( pCopy, NULL, NULL, pSurface, NULL, NULL, D3DX_FILTER_NONE, 0) ) ) { // Update desc from the copy. pCopy->GetDesc( &desc ); D3DLOCKED_RECT lr; { RECT rect; rect.left = 0; rect.top = 0; rect.right = desc.Width; rect.bottom = desc.Height; pCopy->LockRect( &lr, &rect, D3DLOCK_READONLY ); } RageSurface *surface = CreateSurfaceFromPixfmt( FMT_RGBA8, lr.pBits, desc.Width, desc.Height, lr.Pitch); ASSERT( surface != NULL ); // We need to make a copy, since lr.pBits will go away when we call UnlockRect(). result = CreateSurface( surface->w, surface->h, surface->format->BitsPerPixel, surface->format->Rmask, surface->format->Gmask, surface->format->Bmask, surface->format->Amask ); RageSurfaceUtils::CopySurface( surface, result ); delete surface; pCopy->UnlockRect(); } pCopy->Release(); } pSurface->Release(); } return result; #endif }
LPDIRECT3DSURFACE9 LoadSurface(char *filename, D3DCOLOR transcolor) { LPDIRECT3DSURFACE9 image = NULL; D3DXIMAGE_INFO info; HRESULT result; result = D3DXGetImageInfoFromFile(filename, &info); result = d3ddev->CreateOffscreenPlainSurface( info.Width, info.Height, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &image, NULL); result = D3DXLoadSurfaceFromFile( image, NULL, NULL, filename, NULL, D3DX_DEFAULT, transcolor, NULL); return image; }
/*This Function creates a surface object from a bitmap file. Find the dimensions of the bitmap, create the plain surface, then load the bitmap into the new surface object*/ LPDIRECT3DSURFACE9 LoadSurface(string filename) { LPDIRECT3DSURFACE9 image = NULL; //Get width and Height of bitmap D3DXIMAGE_INFO info; HRESULT result = D3DXGetImageInfoFromFile(filename.c_str(), &info); if (result != D3D_OK) return NULL; //creates a new surface object result = d3ddev->CreateOffscreenPlainSurface( info.Width, info.Height, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &image, NULL); if (result != D3D_OK) return NULL; //load the surface from the file into the newley created surface object result = D3DXLoadSurfaceFromFile( image, NULL, NULL, filename.c_str(), NULL, D3DX_DEFAULT, D3DCOLOR_XRGB(0, 0, 0), NULL); if (result != D3D_OK) return NULL; return image; }
HRESULT InitD3D( HWND hWnd ) { HRESULT hr ; // Create the D3D object, which is needed to create the D3DDevice. if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) ) { MessageBox(NULL, "Create D3D9 object failed!", "Error", 0) ; return E_FAIL; } D3DDISPLAYMODE ddm; hr = g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT,&ddm) ; if(FAILED(hr)) { MessageBox(NULL, "Unable to Get Adapter Display Mode", "Error", 0) ; return E_FAIL; } ZeroMemory( &d3dpp, sizeof(d3dpp) ); d3dpp.Windowed = TRUE; d3dpp.BackBufferCount = 1 ; d3dpp.BackBufferWidth = ddm.Width ; d3dpp.BackBufferHeight = ddm.Height ; d3dpp.SwapEffect = D3DSWAPEFFECT_FLIP; d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8; // Create device if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &g_pd3dDevice ) ) ) { MessageBoxA(NULL, "Create D3D9 device failed!", "Error", 0) ; return E_FAIL; } // Create Semaphore variable g_hMutex = CreateMutex(NULL,FALSE,NULL); g_hFullSemaphore = CreateSemaphore(NULL, g_PoolSize - 1, g_PoolSize - 1, NULL); g_hEmptySemaphore = CreateSemaphore(NULL, 0, g_PoolSize - 1, NULL); // Get back buffer g_pd3dDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &g_pBackBuffer) ; // Create surface for (int i = 0; i < g_PoolSize; ++i) { g_SurfPool[i] = NULL ; if (FAILED(hr = g_pd3dDevice->CreateOffscreenPlainSurface(d3dpp.BackBufferWidth, d3dpp.BackBufferHeight, d3dpp.BackBufferFormat, D3DPOOL_SYSTEMMEM, &g_SurfPool[i], NULL))) { return hr; } } return S_OK; }
//---------------------------------------------------------------------------------- // //---------------------------------------------------------------------------------- void InitGraphics(int width, int height ) { InitWindow(width, height); D3DPRESENT_PARAMETERS d3dp; ZeroMemory(&d3dp, sizeof(d3dp)); d3dp.BackBufferWidth = width; d3dp.BackBufferHeight = height; d3dp.BackBufferFormat = D3DFMT_X8R8G8B8; d3dp.BackBufferCount = 1; d3dp.SwapEffect = D3DSWAPEFFECT_DISCARD; d3dp.Windowed = TRUE; d3dp.hDeviceWindow = (HWND)GetHandle(); d3dp.EnableAutoDepthStencil = TRUE; d3dp.AutoDepthStencilFormat = D3DFMT_D16; #if __PerformanceCheckMode d3dp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; #endif g_d3d = Direct3DCreate9(D3D_SDK_VERSION); g_d3d->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, (HWND) GetHandle(), D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dp, &g_d3d_device ); {// 市松模様の背景画像を作る g_d3d_device->CreateOffscreenPlainSurface( width, height, D3DFMT_X8R8G8B8, D3DPOOL_SYSTEMMEM, &g_d3d_clearing_image, NULL ); D3DLOCKED_RECT lockedRect; g_d3d_clearing_image->LockRect( &lockedRect, NULL, 0 ); CreateCheckeredPattern( width, height, (uint32_t*)lockedRect.pBits ); g_d3d_clearing_image->UnlockRect(); } g_renderer = ::EffekseerRendererDX9::Renderer::Create( g_d3d_device, 2000 ); g_renderer->SetProjectionMatrix( ::Effekseer::Matrix44().PerspectiveFovRH( 90.0f / 180.0f * 3.14f, (float)width / (float)height, 1.0f, 50.0f ) ); g_renderer->SetDistortingCallback( new DistortingCallback( (EffekseerRendererDX9::Renderer*)g_renderer, g_d3d_device, width, height ) ); g_manager->SetSpriteRenderer( g_renderer->CreateSpriteRenderer() ); g_manager->SetRibbonRenderer( g_renderer->CreateRibbonRenderer() ); g_manager->SetRingRenderer( g_renderer->CreateRingRenderer() ); g_manager->SetModelRenderer( g_renderer->CreateModelRenderer() ); g_manager->SetTrackRenderer( g_renderer->CreateTrackRenderer() ); g_manager->SetCoordinateSystem( ::Effekseer::CoordinateSystem::RH ); g_manager->SetTextureLoader( g_renderer->CreateTextureLoader() ); g_manager->SetModelLoader( g_renderer->CreateModelLoader() ); }
bool Surface::loadSurface(LPDIRECT3DDEVICE9 device, std::string filename) { imageScale = 100; //set our image scale to 100% //record the height and width HRESULT hResult; // Get the width and height of the image D3DXIMAGE_INFO imageInfo; hResult = D3DXGetImageInfoFromFile(filename.c_str(), &imageInfo); if FAILED (hResult){ return false; } height = imageInfo.Height; width = imageInfo.Width; //create the Off Screen Surface hResult = device->CreateOffscreenPlainSurface(width, //surface width height, //surface height D3DFMT_A8R8G8B8, //surface format, D3DFMT_A8R8G8B8 is a 32 bit format with 8 alpha bits D3DPOOL_DEFAULT, //create it in the default memory pool &surface, //the pointer to our surface NULL ); if (FAILED(hResult)) return false; //load the surface from the a file hResult = D3DXLoadSurfaceFromFile(surface, //the surface we just created NULL, //palette entry, NULL for non 256 color formats NULL, //dest rect, NULL for the whole surface filename.c_str(), // the file we wish to load NULL, // Source Rect, NULL for the whole file D3DX_DEFAULT, //Filter 0, // Color key, color that should be used as transparent. NULL // pointer to a D3DXIMAGE_INFO structure, for holding info about the image. ); if (FAILED(hResult)) return false; //set rects destRect.left = 0; destRect.top = 0; destRect.bottom = destRect.top + height; destRect.right = destRect.left + width; srcRect.left = 0; srcRect.top = 0; srcRect.bottom = destRect.top + height; srcRect.right = destRect.left + width; return true; }
HRESULT HookIDirect3DDevice9::CreateOffscreenPlainSurface(LPVOID _this, UINT Width, UINT Height, D3DFORMAT Format, D3DPOOL Pool, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) { LOG_API(); return pD3Dev->CreateOffscreenPlainSurface(Width, Height, Format, Pool, ppSurface, pSharedHandle); }
LPDIRECT3DSURFACE9 LoadSurface(char* fileName, D3DCOLOR transColor) { LPDIRECT3DSURFACE9 image = NULL; D3DXIMAGE_INFO info; HRESULT hr; hr = D3DXGetImageInfoFromFile(fileName, &info); if (hr != D3D_OK) return NULL; hr = d3dDev->CreateOffscreenPlainSurface(info.Width, info.Height, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &image, NULL); if (hr != D3D_OK) return NULL; hr = D3DXLoadSurfaceFromFile(image, NULL, NULL, fileName, NULL, D3DX_DEFAULT, transColor, NULL); if (hr != D3D_OK) return NULL; return image; }
LPDIRECT3DSURFACE9 LoadSurface(string filename) { LPDIRECT3DSURFACE9 image = NULL; //get width and height from bitmap file D3DXIMAGE_INFO info; HRESULT result = D3DXGetImageInfoFromFile(filename.c_str(), &info); if (result != D3D_OK) { return NULL; } //create surface result = d3ddev->CreateOffscreenPlainSurface( info.Width, info.Height, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &image, NULL); if (result != D3D_OK) return NULL; //load surface from file into newly created surface result = D3DXLoadSurfaceFromFile( image, NULL, NULL, filename.c_str(), NULL, D3DX_DEFAULT, D3DCOLOR_XRGB(0,0,0), NULL); //make sure file was loaded okay if (result != D3D_OK) { return NULL; } return image; }
bool Background::load(LPDIRECT3DDEVICE9 Device, std::wstring filename) { imageScale = 100; HRESULT hr; D3DXIMAGE_INFO imageInfo; hr = D3DXGetImageInfoFromFile(filename.c_str(), &imageInfo); if(FAILED(hr)) { return false; } height = imageInfo.Height; width = imageInfo.Width; hr = Device->CreateOffscreenPlainSurface(width, height, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &background, NULL); if(FAILED(hr)) { return false; } //load from file hr = D3DXLoadSurfaceFromFile(background, NULL, NULL, filename.c_str(), NULL, D3DX_DEFAULT, 0, NULL); if(FAILED(hr)) { return false; } //Set Rects scrRect.left = 0; scrRect.top = 0; scrRect.bottom = 0; scrRect.top = 0; destRect.left = 0; destRect.top = 0; destRect.bottom = 0; destRect.right = 0; return true; }
String screengrab(String filename) { if(filename=="" || filename == " () ") { filename.sprintf("%s_%5.5d_.png",(const char*)screengrabprefix,screengrabcount); screengrabcount++; } if(!IsOneOf('.',filename)) filename << ".png"; HRESULT hr; // get display dimensions // this will be the dimensions of the front buffer D3DDISPLAYMODE mode; if (FAILED(hr=g_pd3dDevice->GetDisplayMode(0,&mode))) { return "fail getdisplaymode"; } // create the image surface to store the front buffer image // note that call to GetFrontBuffer will always convert format to A8R8G8B8 static LPDIRECT3DSURFACE9 surf=NULL; if (!surf && FAILED(hr=g_pd3dDevice->CreateOffscreenPlainSurface(mode.Width,mode.Height, D3DFMT_A8R8G8B8,D3DPOOL_DEFAULT,&surf,NULL))) { return "fail createimagesurface"; } // Next, this surface is passed to the GetFrontBuffer() method of the device, which will copy the entire screen into our image buffer: // read the front buffer into the image surface if (FAILED(hr=g_pd3dDevice->GetBackBuffer(0,0,D3DBACKBUFFER_TYPE_MONO,&surf))) { surf->Release(); return "fail getfrontbuffer"; } //Finally, we call D3DXSaveSurfaceToFile() to create the BMP file, and release the temporary image surface: // write the entire surface to the requested file hr=D3DXSaveSurfaceToFile(filename,D3DXIFF_PNG,surf,NULL,NULL); // release the image surface // surf->Release(); // return status of save operation to caller return (hr==D3D_OK)? filename + " exported!" : "something failed"; }
LPDIRECT3DSURFACE9 CreateSurfaceFromFile(LPDIRECT3DDEVICE9 d3ddv, LPWSTR FilePath) { D3DXIMAGE_INFO info; HRESULT result = D3DXGetImageInfoFromFile(FilePath,&info); if (result!=D3D_OK) { trace(L"[ERROR] Failed to get image info '%s'",FilePath); return NULL; } LPDIRECT3DSURFACE9 surface; d3ddv->CreateOffscreenPlainSurface( info.Width, // width info.Height, // height D3DFMT_X8R8G8B8, // format D3DPOOL_DEFAULT, &surface, NULL); result = D3DXLoadSurfaceFromFile( surface, // surface NULL, // destination palette NULL, // destination rectangle FilePath, NULL, // source rectangle D3DX_DEFAULT, // filter image D3DCOLOR_XRGB(0,0,0), // transparency (0 = none) NULL); // reserved if (result!=D3D_OK) { trace(L"[ERROR] D3DXLoadSurfaceFromFile() failed"); return NULL; } return surface; }
LPDIRECT3DSURFACE9 LoadSurface(string filename) { LPDIRECT3DSURFACE9 image = NULL; //get width and height from bitmap file D3DXIMAGE_INFO info; HRESULT result = D3DXGetImageInfoFromFile(filename.c_str(), &info); if (result != D3D_OK) return NULL; //create surface result = d3ddev->CreateOffscreenPlainSurface( info.Width, //width of the surface info.Height, //height of the surface D3DFMT_X8R8G8B8, //surface format D3DPOOL_DEFAULT, //memory pool to use &image, //pointer to the surface NULL); //reserved (always NULL) if (result != D3D_OK) return NULL; //load surface from file into newly created surface result = D3DXLoadSurfaceFromFile( image, //destination surface NULL, //destination palette NULL, //destination rectangle filename.c_str(), //source filename NULL, //source rectangle D3DX_DEFAULT, //controls how image is filtered D3DCOLOR_XRGB(0,0,0), //for transparency (0 for none) NULL); //source image info (usually NULL) //make sure file was loaded okay if (result != D3D_OK) return NULL; return image; }
//----------------------------------------------------------------------------- // Name: D3DUtil_SetDeviceCursor // Desc: Gives the D3D device a cursor with image and hotspot from hCursor. //----------------------------------------------------------------------------- HRESULT D3DUtil_SetDeviceCursor( LPDIRECT3DDEVICE9 pd3dDevice, HCURSOR hCursor, BOOL bAddWatermark ) { HRESULT hr = E_FAIL; ICONINFO iconinfo; BOOL bBWCursor; LPDIRECT3DSURFACE9 pCursorSurface = NULL; HDC hdcColor = NULL; HDC hdcMask = NULL; HDC hdcScreen = NULL; BITMAP bm; DWORD dwWidth; DWORD dwHeightSrc; DWORD dwHeightDest; COLORREF crColor; COLORREF crMask; UINT x; UINT y; BITMAPINFO bmi; COLORREF* pcrArrayColor = NULL; COLORREF* pcrArrayMask = NULL; DWORD* pBitmap; HGDIOBJ hgdiobjOld; ZeroMemory( &iconinfo, sizeof(iconinfo) ); if( !GetIconInfo( hCursor, &iconinfo ) ) goto End; if (0 == GetObject((HGDIOBJ)iconinfo.hbmMask, sizeof(BITMAP), (LPVOID)&bm)) goto End; dwWidth = bm.bmWidth; dwHeightSrc = bm.bmHeight; if( iconinfo.hbmColor == NULL ) { bBWCursor = TRUE; dwHeightDest = dwHeightSrc / 2; } else { bBWCursor = FALSE; dwHeightDest = dwHeightSrc; } // Create a surface for the fullscreen cursor if( FAILED( hr = pd3dDevice->CreateOffscreenPlainSurface( dwWidth, dwHeightDest, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &pCursorSurface, 0 ) ) ) { goto End; } pcrArrayMask = new DWORD[dwWidth * dwHeightSrc]; ZeroMemory(&bmi, sizeof(bmi)); bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader); bmi.bmiHeader.biWidth = dwWidth; bmi.bmiHeader.biHeight = dwHeightSrc; bmi.bmiHeader.biPlanes = 1; bmi.bmiHeader.biBitCount = 32; bmi.bmiHeader.biCompression = BI_RGB; hdcScreen = GetDC( NULL ); hdcMask = CreateCompatibleDC( hdcScreen ); if( hdcMask == NULL ) { hr = E_FAIL; goto End; } hgdiobjOld = SelectObject(hdcMask, iconinfo.hbmMask); GetDIBits(hdcMask, iconinfo.hbmMask, 0, dwHeightSrc, pcrArrayMask, &bmi, DIB_RGB_COLORS); SelectObject(hdcMask, hgdiobjOld); if (!bBWCursor) { pcrArrayColor = new DWORD[dwWidth * dwHeightDest]; hdcColor = CreateCompatibleDC( hdcScreen ); if( hdcColor == NULL ) { hr = E_FAIL; goto End; } SelectObject(hdcColor, iconinfo.hbmColor); GetDIBits(hdcColor, iconinfo.hbmColor, 0, dwHeightDest, pcrArrayColor, &bmi, DIB_RGB_COLORS); } // Transfer cursor image into the surface D3DLOCKED_RECT lr; pCursorSurface->LockRect( &lr, NULL, 0 ); pBitmap = (DWORD*)lr.pBits; for( y = 0; y < dwHeightDest; y++ ) { for( x = 0; x < dwWidth; x++ ) { if (bBWCursor) { crColor = pcrArrayMask[dwWidth*(dwHeightDest-1-y) + x]; crMask = pcrArrayMask[dwWidth*(dwHeightSrc-1-y) + x]; } else { crColor = pcrArrayColor[dwWidth*(dwHeightDest-1-y) + x]; crMask = pcrArrayMask[dwWidth*(dwHeightDest-1-y) + x]; } if (crMask == 0) pBitmap[dwWidth*y + x] = 0xff000000 | crColor; else pBitmap[dwWidth*y + x] = 0x00000000; // It may be helpful to make the D3D cursor look slightly // different from the Windows cursor so you can distinguish // between the two when developing/testing code. When // bAddWatermark is TRUE, the following code adds some // small grey "D3D" characters to the upper-left corner of // the D3D cursor image. if( bAddWatermark && x < 12 && y < 5 ) { // 11.. 11.. 11.. .... CCC0 // 1.1. ..1. 1.1. .... A2A0 // 1.1. .1.. 1.1. .... A4A0 // 1.1. ..1. 1.1. .... A2A0 // 11.. 11.. 11.. .... CCC0 const WORD wMask[5] = { 0xccc0, 0xa2a0, 0xa4a0, 0xa2a0, 0xccc0 }; if( wMask[y] & (1 << (15 - x)) ) { pBitmap[dwWidth*y + x] |= 0xff808080; } } } } pCursorSurface->UnlockRect(); // Set the device cursor if( FAILED( hr = pd3dDevice->SetCursorProperties( iconinfo.xHotspot, iconinfo.yHotspot, pCursorSurface ) ) ) { goto End; } hr = S_OK; End: if( iconinfo.hbmMask != NULL ) DeleteObject( iconinfo.hbmMask ); if( iconinfo.hbmColor != NULL ) DeleteObject( iconinfo.hbmColor ); if( hdcScreen != NULL ) ReleaseDC( NULL, hdcScreen ); if( hdcColor != NULL ) DeleteDC( hdcColor ); if( hdcMask != NULL ) DeleteDC( hdcMask ); SAFE_DELETE_ARRAY( pcrArrayColor ); SAFE_DELETE_ARRAY( pcrArrayMask ); SAFE_RELEASE( pCursorSurface ); return hr; }
/* * Game initialization function */ bool Game_Init(HWND window) { //initialize Direct3D d3d = Direct3DCreate9(D3D_SDK_VERSION); if (!d3d) { MessageBox(window, "Error initializing Direct3D", "Error", MB_OK); return false; } //set Direct3D presentation parameters D3DPRESENT_PARAMETERS d3dpp; ZeroMemory(&d3dpp, sizeof(d3dpp)); d3dpp.Windowed = TRUE; d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8; d3dpp.BackBufferCount = 1; d3dpp.BackBufferWidth = SCREENW; d3dpp.BackBufferHeight = SCREENH; d3dpp.hDeviceWindow = window; //create Direct3D device d3d->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &d3ddev); if (!d3ddev) { MessageBox(window, "Error creating Direct3D device", "Error", MB_OK); return 0; } //clear the backbuffer to black d3ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,0), 1.0f, 0); //create surface HRESULT result = d3ddev->CreateOffscreenPlainSurface( SCREENW, //width of the surface SCREENH, //height of the surface D3DFMT_X8R8G8B8, //surface format D3DPOOL_DEFAULT, //memory pool to use &surface, //pointer to the surface NULL); //reserved (always NULL) if (!SUCCEEDED(result)) return false; //load surface from file into newly created surface result = D3DXLoadSurfaceFromFile( surface, //destination surface NULL, //destination palette NULL, //destination rectangle "legotron.bmp", //source filename NULL, //source rectangle D3DX_DEFAULT, //controls how image is filtered 0, //for transparency NULL); //source image info //make sure file was loaded okay if (!SUCCEEDED(result)) return false; return true; }
void* CDX9TextureObject::Read( int level, bool bForceUpdateRead ) { ReadyData(); //level currently ignored, read cannot read mipmaps if( m_Texture ) { LPDIRECT3DDEVICE9 pDevice; if( !m_Renderer ) { return NULL; } pDevice = (LPDIRECT3DDEVICE9)m_Renderer->GetAPIDevice(); if( !pDevice ) { return NULL; } int iTextureSize = (GetColorDepth() / 8) * GetWidth() * GetHeight(); // delete the old buffer if our current one is the wrong size if (m_pLocalBuffer && (iTextureSize != m_iLocalBufferSize)) { delete[] m_pLocalBuffer; m_pLocalBuffer = NULL; m_iLocalBufferSize = 0; } // allocate a new buffer if we don't have one if (!m_pLocalBuffer) { m_pLocalBuffer = new unsigned char[iTextureSize]; m_iLocalBufferSize = iTextureSize; } else { // return current buffer if we aren't forcing a read if (!bForceUpdateRead) return m_pLocalBuffer; } //check what kind of a surface it is, we have to get the surface if it's a rendertarget! if( !m_bRenderTarget ) { if( m_Compressed ) { LPDIRECT3DSURFACE9 Src = NULL; m_Texture->GetSurfaceLevel( 0, &Src ); //convert format to argb first LPDIRECT3DSURFACE9 tempSurf = NULL; HRESULT hr = pDevice->CreateOffscreenPlainSurface( GetWidth(), GetHeight(), D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tempSurf, NULL ); if( hr != D3D_OK || tempSurf == NULL || Src == NULL ) { SAFE_RELEASE( Src ); SAFE_RELEASE( tempSurf ); return NULL; } hr = D3DXLoadSurfaceFromSurface( tempSurf, NULL, NULL, Src, NULL, NULL, D3DX_DEFAULT, 0 ); if( hr != D3D_OK ) { return NULL; } //lock the texture and read the data D3DLOCKED_RECT lockrect; hr = tempSurf->LockRect( &lockrect, NULL, D3DLOCK_READONLY ); if( hr == D3D_OK ) { UINT pixelsize = (GetColorDepth()/8); BYTE * srcbits = (BYTE*)lockrect.pBits; BYTE * destbits = (BYTE*)m_pLocalBuffer; //write the texture to the buffer for( UINT i = 0; i < m_Height; i++ ) { memcpy( destbits, srcbits, m_Width*pixelsize ); //move by pitch srcbits += lockrect.Pitch; destbits += m_Width*pixelsize; } } tempSurf->UnlockRect(); SAFE_RELEASE( tempSurf ); SAFE_RELEASE( Src ); return m_pLocalBuffer; } else { //lock the texture and read the data D3DLOCKED_RECT lockrect; HRESULT hr = m_Texture->LockRect( 0, &lockrect, NULL, D3DLOCK_READONLY ); if( hr == D3D_OK ) { UINT pixelsize = (GetColorDepth()/8); BYTE * srcbits = (BYTE*)lockrect.pBits; BYTE * destbits = (BYTE*)m_pLocalBuffer; //write the texture to the buffer for( UINT i = 0; i < m_Height; i++ ) { memcpy( destbits, srcbits, m_Width*pixelsize ); //move by pitch srcbits += lockrect.Pitch; destbits += m_Width*pixelsize; } } m_Texture->UnlockRect( 0 ); return m_pLocalBuffer; } }else//we are render target, need surface { LPDIRECT3DSURFACE9 RenderSurf = NULL; LPDIRECT3DSURFACE9 OffSurf = NULL; m_Texture->GetSurfaceLevel( 0, &RenderSurf ); if( RenderSurf ) { D3DSURFACE_DESC tDesc; m_Texture->GetLevelDesc(0, &tDesc ); if( FAILED(pDevice->CreateOffscreenPlainSurface( tDesc.Width, tDesc.Height, tDesc.Format, D3DPOOL_SYSTEMMEM, &OffSurf, NULL ))) { RenderSurf->Release(); return NULL; } if( FAILED( pDevice->GetRenderTargetData( RenderSurf, OffSurf ) )) { RenderSurf->Release(); OffSurf->Release(); return NULL; } //No need for rendertarget surface anymore RenderSurf->Release(); //lock the texture and read the data D3DLOCKED_RECT lockrect; HRESULT hr = OffSurf->LockRect( &lockrect, NULL, D3DLOCK_READONLY ); if( hr == D3D_OK ) { UINT pixelsize = (GetColorDepth()/8); BYTE * srcbits = (BYTE*)lockrect.pBits; BYTE * destbits = (BYTE*)m_pLocalBuffer; //write the texture to the buffer for( UINT i = 0; i < m_Height; i++ ) { memcpy( destbits, srcbits, m_Width*pixelsize ); //move by pitch srcbits += lockrect.Pitch; destbits += m_Width*pixelsize; } } OffSurf->UnlockRect(); OffSurf->Release(); } return m_pLocalBuffer; } } return NULL; }
void BackBuffer() { IDirect3DSurface9 *ppBackBuffer, *ppOffScreen; HRESULT back; D3DXIMAGE_INFO pSrcInfo; if (SUCCEEDED(back = g_pd3dDevice->CreateOffscreenPlainSurface( 256, 256, D3DFMT_X8R8G8B8, D3DPOOL_SYSTEMMEM, &ppOffScreen, NULL))) { if (SUCCEEDED( back = D3DXLoadSurfaceFromFile( ppOffScreen, NULL, NULL, "bana.bmp", NULL, D3DX_FILTER_TRIANGLE, 0, &pSrcInfo))) { back = NULL; } else if (back == D3DERR_INVALIDCALL) { back = 0; } else if (back == D3DXERR_INVALIDDATA) { pSrcInfo.Width; back = 1; } else { back = 2; } } //if (SUCCEEDED(g_pd3dDevice->GetRenderTarget(0, &ppBackBuffer))) if (SUCCEEDED(g_pd3dDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &ppBackBuffer))) { D3DSURFACE_DESC pDesc; ppBackBuffer->GetDesc(&pDesc); POINT pDestinationPoint; for (int i=0; i<4; i++) { pDestinationPoint.x = i*pSrcInfo.Width; for (int j=0; j<4; j++) { pDestinationPoint.y = j*pSrcInfo.Height; if (SUCCEEDED(back = g_pd3dDevice->UpdateSurface(ppOffScreen, NULL, ppBackBuffer, &pDestinationPoint))) { back = 0; } } } } ppBackBuffer->Release(); ppOffScreen->Release(); /* if (SUCCEEDED(back = g_pd3dDevice->CreateRenderTarget( 256, 256, D3DFMT_R8G8B8, D3DMULTISAMPLE_NONE, 0, true, &ppBackBuffer, NULL))) */ /*if (SUCCEEDED(back = g_pd3dDevice->CreateDepthStencilSurface( 256, 256, D3DFMT_D16, D3DMULTISAMPLE_NONE, 0, true, &ppBackBuffer, NULL)))*/ //if (SUCCEEDED(g_pd3dDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &ppBackBuffer))) /* D3DLOCKED_RECT pLockedRect; if (SUCCEEDED(back = ppBackBuffer->LockRect(&pLockedRect, NULL, D3DLOCK_READONLY))) { back=1; } */ /* HDC phdc; if (SUCCEEDED(back = ppBackBuffer->GetDC(&phdc))) //if (SUCCEEDED(back = ppBackBuffer->LockRect(&pLockedRect, NULL, D3DLOCK_READONLY))) { BYTE* pSrcTopRow = (BYTE*)pLockedRect.pBits; DWORD dwSrcPitch = (DWORD)pLockedRect.Pitch; *pSrcTopRow =1; //for(int i=0;i<1;i++) // *(pSrcTopRow+(i*dwSrcPitch)) = 1; } else if (back == D3DERR_INVALIDCALL) { back = 0; } else if(back == D3DERR_WASSTILLDRAWING) { back = 0; } */ // ppBackBuffer->UnlockRect(); }