| /* |
| * Copyright (c) 2007, 2008, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| #include "D3DResourceManager.h" |
| #include "awt.h" |
| #include "D3DPaints.h" |
| #include "D3DTextRenderer.h" |
| |
| void |
| D3DResource::Init(IDirect3DResource9 *pRes, IDirect3DSwapChain9 *pSC) |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DResource::Init"); |
| |
| pResource = NULL; |
| pSwapChain = pSC; |
| pSurface = NULL; |
| pTexture = NULL; |
| pOps = NULL; |
| ZeroMemory(&desc, sizeof(desc)); |
| desc.Format = D3DFMT_UNKNOWN; |
| |
| if (pRes != NULL) { |
| pResource = pRes; |
| |
| D3DRESOURCETYPE type = pResource->GetType(); |
| switch (type) { |
| case D3DRTYPE_TEXTURE: |
| // addRef is needed because both pResource and pTexture will be |
| // Release()d, and they point to the same object |
| pResource->AddRef(); |
| pTexture = (IDirect3DTexture9*)pResource; |
| pTexture->GetSurfaceLevel(0, &pSurface); |
| break; |
| case D3DRTYPE_SURFACE: |
| pResource->AddRef(); |
| pSurface = (IDirect3DSurface9*)pResource; |
| break; |
| case D3DRTYPE_CUBETEXTURE: |
| ((IDirect3DCubeTexture9*)pResource)->GetLevelDesc(0, &desc); |
| break; |
| default: |
| J2dTraceLn1(J2D_TRACE_VERBOSE, " resource type=%d", type); |
| } |
| } else if (pSwapChain != NULL) { |
| pSwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &pSurface); |
| } else { |
| J2dTraceLn(J2D_TRACE_VERBOSE, " pResource == pSwapChain == NULL"); |
| } |
| |
| if (pSurface != NULL) { |
| pSurface->GetDesc(&desc); |
| } |
| |
| SAFE_PRINTLN(pResource); |
| SAFE_PRINTLN(pSurface); |
| SAFE_PRINTLN(pTexture); |
| SAFE_PRINTLN(pSwapChain); |
| } |
| |
| D3DResource::~D3DResource() |
| { |
| Release(); |
| } |
| |
| void |
| D3DResource::SetSDOps(D3DSDOps *pOps) |
| { |
| if (pOps != NULL && this->pOps != NULL) { |
| // something's wrong, we're overwriting |
| // a non-null field (setting it to null is allowed) |
| J2dTraceLn2(J2D_TRACE_WARNING, |
| "D3DResource::SetSDOps: overwriting "\ |
| "this->pOps=0x%x with pOps=0x%x", this->pOps, pOps); |
| } |
| this->pOps = pOps; |
| } |
| |
| BOOL |
| D3DResource::IsDefaultPool() |
| { |
| if (desc.Format != D3DFMT_UNKNOWN) { |
| return (desc.Pool == D3DPOOL_DEFAULT); |
| } |
| return TRUE; |
| } |
| |
| void |
| D3DResource::Release() |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DResource::Release"); |
| |
| SAFE_PRINTLN(pResource); |
| SAFE_PRINTLN(pSurface); |
| SAFE_PRINTLN(pTexture); |
| SAFE_PRINTLN(pSwapChain); |
| |
| SAFE_RELEASE(pSurface); |
| SAFE_RELEASE(pTexture); |
| SAFE_RELEASE(pResource); |
| SAFE_RELEASE(pSwapChain); |
| |
| if (pOps != NULL) { |
| // if sdOps is not NULL it means that the release was initiated |
| // from the native level, and is caused by a surface loss |
| D3DSD_MarkLost(pOps); |
| pOps->pResource = NULL; |
| pOps = NULL; |
| } |
| } |
| |
| HRESULT |
| D3DResourceManager::CreateInstance(D3DContext *pCtx, |
| D3DResourceManager** ppResourceMgr) |
| { |
| HRESULT res; |
| |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::CreateInstance"); |
| |
| *ppResourceMgr = new D3DResourceManager(); |
| if (FAILED(res = (*ppResourceMgr)->Init(pCtx))) { |
| delete *ppResourceMgr; |
| *ppResourceMgr = NULL; |
| } |
| return res; |
| } |
| |
| D3DResourceManager::D3DResourceManager() |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::D3DRM"); |
| |
| this->pCtx = NULL; |
| this->pHead = NULL; |
| } |
| |
| HRESULT |
| D3DResourceManager::Init(D3DContext *pCtx) |
| { |
| J2dTraceLn1(J2D_TRACE_INFO, "D3DRM::Init pCtx=%x", pCtx); |
| if (this->pCtx != pCtx || |
| (this->pCtx != NULL && |
| this->pCtx->Get3DDevice() != pCtx->Get3DDevice())) |
| { |
| ReleaseAll(); |
| } |
| this->pCtx = pCtx; |
| return S_OK; |
| } |
| |
| D3DResourceManager::~D3DResourceManager() |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::~D3DRM"); |
| ReleaseAll(); |
| pCtx = NULL; |
| pHead = NULL; |
| } |
| |
| void |
| D3DResourceManager::ReleaseAll() |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::ReleaseAll"); |
| IManagedResource* pCurrent; |
| while (pHead != NULL) { |
| pCurrent = pHead; |
| pHead = pHead->pNext; |
| delete pCurrent; |
| } |
| pCachedDestTexture = NULL; |
| pBlitTexture = NULL; |
| pBlitRTTexture = NULL; |
| pBlitOSPSurface = NULL; |
| pGradientTexture = NULL; |
| pLookupOpLutTexture = NULL; |
| pMaskTexture = NULL; |
| pMultiGradientTexture = NULL; |
| pLockableRTSurface = NULL; |
| } |
| |
| void |
| D3DResourceManager::ReleaseDefPoolResources() |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::ReleaseDefPoolResources"); |
| // REMIND: for now, release all resources |
| ReleaseAll(); |
| } |
| |
| HRESULT |
| D3DResourceManager::ReleaseResource(IManagedResource* pResource) |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::ReleaseResource"); |
| |
| if (pResource != NULL) { |
| J2dTraceLn1(J2D_TRACE_VERBOSE, " releasing pResource=%x", pResource); |
| if (pResource->pPrev != NULL) { |
| pResource->pPrev->pNext = pResource->pNext; |
| } else { |
| // it's the head |
| pHead = pResource->pNext; |
| if (pHead != NULL) { |
| pHead->pPrev = NULL; |
| } |
| } |
| if (pResource->pNext != NULL) { |
| pResource->pNext->pPrev = pResource->pPrev; |
| } |
| delete pResource; |
| } |
| return S_OK; |
| } |
| |
| HRESULT |
| D3DResourceManager::AddResource(IManagedResource* pResource) |
| { |
| HRESULT res = S_OK; |
| |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::AddResource"); |
| |
| if (pResource != NULL) { |
| J2dTraceLn1(J2D_TRACE_VERBOSE, " pResource=%x", pResource); |
| pResource->pPrev = NULL; |
| pResource->pNext = pHead; |
| if (pHead != NULL) { |
| pHead->pPrev = pResource; |
| } |
| pHead = pResource; |
| } |
| |
| return S_OK; |
| } |
| |
| HRESULT |
| D3DResourceManager::CreateTexture(UINT width, UINT height, |
| BOOL isRTT, BOOL isOpaque, |
| D3DFORMAT *pFormat, DWORD dwUsage, |
| D3DResource **ppTextureResource) |
| { |
| D3DPOOL pool; |
| D3DFORMAT format; |
| HRESULT res; |
| IDirect3DDevice9 *pd3dDevice; |
| |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::CreateTexture"); |
| J2dTraceLn4(J2D_TRACE_VERBOSE, " w=%d h=%d isRTT=%d isOpaque=%d", |
| width, height, isRTT, isOpaque); |
| |
| if (ppTextureResource == NULL || pCtx == NULL || |
| (pd3dDevice = pCtx->Get3DDevice()) == NULL) |
| { |
| return E_FAIL; |
| } |
| if (FAILED(res = pd3dDevice->TestCooperativeLevel())) { |
| return res; |
| } |
| |
| if (pFormat != NULL && *pFormat != D3DFMT_UNKNOWN) { |
| format = *pFormat; |
| } else { |
| if (isOpaque) { |
| format = D3DFMT_X8R8G8B8; |
| } else { |
| format = D3DFMT_A8R8G8B8; |
| } |
| } |
| |
| if (isRTT) { |
| dwUsage = D3DUSAGE_RENDERTARGET; |
| pool = D3DPOOL_DEFAULT; |
| } else { |
| if (dwUsage == D3DUSAGE_DYNAMIC && !pCtx->IsDynamicTextureSupported()) { |
| dwUsage = 0; |
| } |
| if (dwUsage == D3DUSAGE_DYNAMIC) { |
| pool = D3DPOOL_DEFAULT; |
| } else { |
| pool = pCtx->IsHWRasterizer() ? |
| D3DPOOL_MANAGED : D3DPOOL_SYSTEMMEM; |
| } |
| } |
| |
| if (pCtx->IsPow2TexturesOnly()) { |
| UINT w, h; |
| for (w = 1; width > w; w <<= 1); |
| for (h = 1; height > h; h <<= 1); |
| width = w; |
| height = h; |
| } |
| if (pCtx->IsSquareTexturesOnly()) { |
| if (width > height) { |
| height = width; |
| } else { |
| width = height; |
| } |
| } |
| |
| IDirect3DTexture9 *pTexture = NULL; |
| res = pd3dDevice->CreateTexture(width, height, 1/*levels*/, dwUsage, |
| format, pool, &pTexture, 0); |
| if (SUCCEEDED(res)) { |
| J2dTraceLn1(J2D_TRACE_VERBOSE, " created texture: 0x%x", pTexture); |
| *ppTextureResource = new D3DResource((IDirect3DResource9*)pTexture); |
| res = AddResource(*ppTextureResource); |
| } else { |
| DebugPrintD3DError(res, "D3DRM::CreateTexture failed"); |
| *ppTextureResource = NULL; |
| format = D3DFMT_UNKNOWN; |
| } |
| |
| if (pFormat != NULL) { |
| *pFormat = format; |
| } |
| |
| return res; |
| } |
| |
| HRESULT D3DResourceManager::CreateRTSurface(UINT width, UINT height, |
| BOOL isOpaque, BOOL isLockable, |
| D3DFORMAT *pFormat/*out*/, |
| D3DResource** ppSurfaceResource/*out*/) |
| { |
| HRESULT res; |
| IDirect3DDevice9 *pd3dDevice; |
| |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::CreateRTSurface"); |
| J2dTraceLn3(J2D_TRACE_VERBOSE, " w=%d h=%d isOpaque=%d", |
| width, height, isOpaque); |
| |
| if (pCtx == NULL || ppSurfaceResource == NULL || |
| (pd3dDevice = pCtx->Get3DDevice()) == NULL) |
| { |
| return E_FAIL; |
| } |
| if (FAILED(res = pd3dDevice->TestCooperativeLevel())) { |
| return res; |
| } |
| |
| D3DPRESENT_PARAMETERS *curParams = pCtx->GetPresentationParams(); |
| D3DFORMAT format = isOpaque ? curParams->BackBufferFormat : D3DFMT_A8R8G8B8; |
| IDirect3DSurface9 *pSurface = NULL; |
| |
| res = pd3dDevice->CreateRenderTarget(width, height, format, |
| D3DMULTISAMPLE_NONE, 0, |
| isLockable, |
| &pSurface, NULL); |
| if (SUCCEEDED(res)) { |
| J2dTraceLn1(J2D_TRACE_VERBOSE, " created RT Surface: 0x%x ", pSurface); |
| if (pFormat != NULL) { |
| *pFormat = format; |
| } |
| *ppSurfaceResource = new D3DResource((IDirect3DResource9*)pSurface); |
| res = AddResource(*ppSurfaceResource); |
| } else { |
| DebugPrintD3DError(res, "D3DRM::CreateRTSurface failed"); |
| ppSurfaceResource = NULL; |
| } |
| return res; |
| } |
| |
| // REMIND: this method is currently unused; consider removing it later... |
| HRESULT D3DResourceManager::CreateOSPSurface(UINT width, UINT height, |
| D3DFORMAT fmt, |
| D3DResource** ppSurfaceResource/*out*/) |
| { |
| HRESULT res; |
| IDirect3DDevice9 *pd3dDevice; |
| |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::CreateOSPSurface"); |
| J2dTraceLn2(J2D_TRACE_VERBOSE, " w=%d h=%d", width, height); |
| |
| if (pCtx == NULL || ppSurfaceResource == NULL || |
| (pd3dDevice = pCtx->Get3DDevice()) == NULL) |
| { |
| return E_FAIL; |
| } |
| if (FAILED(res = pd3dDevice->TestCooperativeLevel())) { |
| return res; |
| } |
| |
| // since the off-screen plain surface is intended to be used with |
| // the UpdateSurface() method, it is essential that it be created |
| // in the same format as the destination and allocated in the |
| // SYSTEMMEM pool (otherwise UpdateSurface() will fail) |
| D3DFORMAT format; |
| if (fmt == D3DFMT_UNKNOWN) { |
| format = pCtx->GetPresentationParams()->BackBufferFormat; |
| } else { |
| format = fmt; |
| } |
| D3DPOOL pool = D3DPOOL_SYSTEMMEM; |
| IDirect3DSurface9 *pSurface = NULL; |
| |
| res = pd3dDevice->CreateOffscreenPlainSurface(width, height, |
| format, pool, |
| &pSurface, NULL); |
| if (SUCCEEDED(res)) { |
| J2dTraceLn1(J2D_TRACE_VERBOSE, " created OSP Surface: 0x%x ",pSurface); |
| *ppSurfaceResource = new D3DResource((IDirect3DResource9*)pSurface); |
| res = AddResource(*ppSurfaceResource); |
| } else { |
| DebugPrintD3DError(res, "D3DRM::CreateOSPSurface failed"); |
| ppSurfaceResource = NULL; |
| } |
| return res; |
| } |
| |
| HRESULT |
| D3DResourceManager::CreateSwapChain(HWND hWnd, UINT numBuffers, |
| UINT width, UINT height, |
| D3DSWAPEFFECT swapEffect, |
| UINT presentationInterval, |
| D3DResource ** ppSwapChainResource) |
| { |
| HRESULT res; |
| IDirect3DDevice9 *pd3dDevice; |
| IDirect3DSwapChain9 *pSwapChain = NULL; |
| D3DPRESENT_PARAMETERS newParams, *curParams; |
| |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::CreateSwapChain"); |
| J2dTraceLn4(J2D_TRACE_VERBOSE, " w=%d h=%d hwnd=%x numBuffers=%d", |
| width, height, hWnd, numBuffers); |
| |
| if (pCtx == NULL || ppSwapChainResource == NULL || |
| (pd3dDevice = pCtx->Get3DDevice()) == NULL) |
| { |
| return E_FAIL; |
| } |
| RETURN_STATUS_IF_FAILED(res = pd3dDevice->TestCooperativeLevel()); |
| |
| curParams = pCtx->GetPresentationParams(); |
| |
| if (curParams->Windowed == FALSE) { |
| // there's a single swap chain in full-screen mode, use it if |
| // it fits our parameters, reset the device otherwise |
| if (curParams->BackBufferCount != numBuffers || |
| curParams->SwapEffect != swapEffect || |
| curParams->PresentationInterval != presentationInterval) |
| { |
| newParams = *curParams; |
| newParams.BackBufferCount = numBuffers; |
| newParams.SwapEffect = swapEffect; |
| newParams.PresentationInterval = presentationInterval; |
| |
| res = pCtx->ConfigureContext(&newParams); |
| RETURN_STATUS_IF_FAILED(res); |
| // this reset will not have released the device, so our pd3dDevice |
| // is still valid, but to be on a safe side, reset it |
| pd3dDevice = pCtx->Get3DDevice(); |
| } |
| res = pd3dDevice->GetSwapChain(0, &pSwapChain); |
| } else { |
| ZeroMemory(&newParams, sizeof(D3DPRESENT_PARAMETERS)); |
| newParams.BackBufferWidth = width; |
| newParams.BackBufferHeight = height; |
| newParams.hDeviceWindow = hWnd; |
| newParams.Windowed = TRUE; |
| newParams.BackBufferCount = numBuffers; |
| newParams.SwapEffect = swapEffect; |
| newParams.PresentationInterval = presentationInterval; |
| |
| res = pd3dDevice->CreateAdditionalSwapChain(&newParams, &pSwapChain); |
| } |
| |
| if (SUCCEEDED(res)) { |
| J2dTraceLn1(J2D_TRACE_VERBOSE," created swap chain: 0x%x ",pSwapChain); |
| *ppSwapChainResource = new D3DResource(pSwapChain); |
| res = AddResource(*ppSwapChainResource); |
| } else { |
| DebugPrintD3DError(res, "D3DRM::CreateSwapChain failed"); |
| *ppSwapChainResource = NULL; |
| } |
| return res; |
| } |
| |
| HRESULT |
| D3DResourceManager::GetMaskTexture(D3DResource **ppTextureResource) |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::GetMaskTexture"); |
| |
| RETURN_STATUS_IF_NULL(pCtx, E_FAIL); |
| RETURN_STATUS_IF_NULL(ppTextureResource, E_FAIL); |
| |
| D3DFORMAT format = pCtx->IsTextureFormatSupported(D3DFMT_A8) ? |
| D3DFMT_A8 : D3DFMT_A8R8G8B8; |
| |
| jboolean needsInit = (pMaskTexture == NULL); |
| HRESULT res; |
| if (FAILED(res = |
| GetStockTextureResource(D3D_MASK_CACHE_WIDTH_IN_TEXELS, |
| D3D_MASK_CACHE_HEIGHT_IN_TEXELS, |
| FALSE/*isRTT*/, FALSE/*isOpaque*/, &format, 0, |
| &pMaskTexture))) |
| { |
| return res; |
| } |
| |
| if (needsInit) { |
| // init special fully opaque tile in the upper-right corner of |
| // the mask cache texture |
| jubyte allOnes[D3D_MASK_CACHE_TILE_SIZE]; |
| memset(allOnes, 0xff, D3D_MASK_CACHE_TILE_SIZE); |
| if (FAILED(res = pCtx->UploadTileToTexture( |
| pMaskTexture, |
| allOnes, |
| D3D_MASK_CACHE_SPECIAL_TILE_X, |
| D3D_MASK_CACHE_SPECIAL_TILE_Y, |
| 0, 0, |
| D3D_MASK_CACHE_TILE_WIDTH, |
| D3D_MASK_CACHE_TILE_HEIGHT, |
| D3D_MASK_CACHE_TILE_WIDTH, |
| TILEFMT_1BYTE_ALPHA))) |
| { |
| return res; |
| } |
| } |
| |
| *ppTextureResource = pMaskTexture; |
| |
| return res; |
| } |
| |
| HRESULT |
| D3DResourceManager::GetBlitTexture(D3DResource **ppTextureResource) |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::GetBlitTexture"); |
| |
| RETURN_STATUS_IF_NULL(pCtx, E_FAIL); |
| RETURN_STATUS_IF_NULL(ppTextureResource, E_FAIL); |
| |
| HRESULT res = |
| GetStockTextureResource(D3DC_BLIT_TILE_SIZE, D3DC_BLIT_TILE_SIZE, |
| FALSE/*isRTT*/, FALSE/*isOpaque*/, NULL, |
| D3DUSAGE_DYNAMIC, |
| &pBlitTexture); |
| *ppTextureResource = pBlitTexture; |
| |
| return res; |
| } |
| |
| HRESULT |
| D3DResourceManager::GetGradientTexture(D3DResource **ppTextureResource) |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::GetGradientTexture"); |
| |
| RETURN_STATUS_IF_NULL(pCtx, E_FAIL); |
| RETURN_STATUS_IF_NULL(ppTextureResource, E_FAIL); |
| |
| HRESULT res = |
| GetStockTextureResource(2, 1, |
| FALSE/*isRTT*/, FALSE/*isOpaque*/, NULL, 0, |
| &pGradientTexture); |
| *ppTextureResource = pGradientTexture; |
| |
| return res; |
| } |
| |
| HRESULT |
| D3DResourceManager::GetMultiGradientTexture(D3DResource **ppTextureResource) |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::GetMultiGradientTexture"); |
| |
| RETURN_STATUS_IF_NULL(pCtx, E_FAIL); |
| RETURN_STATUS_IF_NULL(ppTextureResource, E_FAIL); |
| |
| HRESULT res = |
| GetStockTextureResource(MAX_MULTI_GRADIENT_COLORS, 1, |
| FALSE/*isRTT*/, FALSE/*isOpaque*/, NULL, 0, |
| &pMultiGradientTexture); |
| *ppTextureResource = pMultiGradientTexture; |
| |
| return res; |
| } |
| |
| HRESULT |
| D3DResourceManager::GetLookupOpLutTexture(D3DResource **ppTextureResource) |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::GetLookupOpTexture"); |
| |
| RETURN_STATUS_IF_NULL(pCtx, E_FAIL); |
| RETURN_STATUS_IF_NULL(ppTextureResource, E_FAIL); |
| |
| D3DFORMAT format = D3DFMT_L16; |
| HRESULT res = |
| GetStockTextureResource(256, 4, |
| FALSE/*isRTT*/, FALSE/*isOpaque*/, &format, 0, |
| &pLookupOpLutTexture); |
| *ppTextureResource = pLookupOpLutTexture; |
| |
| return res; |
| } |
| |
| HRESULT |
| D3DResourceManager::GetBlitRTTexture(UINT width, UINT height, D3DFORMAT format, |
| D3DResource **ppTextureResource) |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::GetBlitRTTexture"); |
| RETURN_STATUS_IF_NULL(pCtx, E_FAIL); |
| RETURN_STATUS_IF_NULL(ppTextureResource, E_FAIL); |
| |
| HRESULT res = GetStockTextureResource(width, height, |
| TRUE/*isRTT*/, FALSE/*isOpaque*/, |
| &format, 0, |
| &pBlitRTTexture); |
| if (SUCCEEDED(res)) { |
| D3DSURFACE_DESC *pDesc = pBlitRTTexture->GetDesc(); |
| D3DCAPS9 *pDevCaps = pCtx->GetDeviceCaps(); |
| if ((width <= pDesc->Width && height <= pDesc->Height) && |
| (format == pDesc->Format || |
| SUCCEEDED(pCtx->Get3DObject()->CheckDeviceFormatConversion( |
| pDevCaps->AdapterOrdinal, |
| pDevCaps->DeviceType, format, pDesc->Format)))) |
| { |
| *ppTextureResource = pBlitRTTexture; |
| return res; |
| } |
| // current texture doesn't fit, release and allocate a new one |
| ReleaseResource(pBlitRTTexture); |
| pBlitRTTexture = NULL; |
| } |
| if (width < D3DC_BLIT_TILE_SIZE) width = D3DC_BLIT_TILE_SIZE; |
| if (height < D3DC_BLIT_TILE_SIZE) height = D3DC_BLIT_TILE_SIZE; |
| |
| res = CreateTexture(width, height, TRUE, FALSE, &format, 0,&pBlitRTTexture); |
| *ppTextureResource = pBlitRTTexture; |
| |
| return res; |
| } |
| |
| HRESULT |
| D3DResourceManager::GetBlitOSPSurface(UINT width, UINT height, D3DFORMAT fmt, |
| D3DResource **ppSurfaceResource) |
| { |
| HRESULT res = S_OK; |
| |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::GetBlitOSPSurface"); |
| RETURN_STATUS_IF_NULL(pCtx, E_FAIL); |
| RETURN_STATUS_IF_NULL(ppSurfaceResource, E_FAIL); |
| |
| if (pBlitOSPSurface != NULL) { |
| D3DSURFACE_DESC *pDesc = pBlitOSPSurface->GetDesc(); |
| if (width == pDesc->Width && height == pDesc->Height && |
| (fmt == pDesc->Format || fmt == D3DFMT_UNKNOWN)) |
| { |
| *ppSurfaceResource = pBlitOSPSurface; |
| return res; |
| } |
| // current surface doesn't fit, release and allocate a new one |
| ReleaseResource(pBlitOSPSurface); |
| pBlitOSPSurface = NULL; |
| } |
| |
| res = CreateOSPSurface(width, height, fmt, &pBlitOSPSurface); |
| *ppSurfaceResource = pBlitOSPSurface; |
| |
| return res; |
| } |
| |
| HRESULT |
| D3DResourceManager::GetLockableRTSurface(UINT width, UINT height, |
| D3DFORMAT format, |
| D3DResource **ppSurfaceResource) |
| { |
| HRESULT res = S_OK; |
| |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::GetLockableRTSurface"); |
| RETURN_STATUS_IF_NULL(pCtx, E_FAIL); |
| RETURN_STATUS_IF_NULL(ppSurfaceResource, E_FAIL); |
| |
| if (pLockableRTSurface != NULL) { |
| D3DSURFACE_DESC *pDesc = pLockableRTSurface->GetDesc(); |
| if (width <= pDesc->Width && height <= pDesc->Height && |
| format == pDesc->Format) |
| { |
| *ppSurfaceResource = pLockableRTSurface; |
| return res; |
| } |
| // current surface doesn't fit, release and allocate a new one |
| ReleaseResource(pLockableRTSurface); |
| pLockableRTSurface = NULL; |
| } |
| if (width < D3DC_BLIT_TILE_SIZE) width = D3DC_BLIT_TILE_SIZE; |
| if (height < D3DC_BLIT_TILE_SIZE) height = D3DC_BLIT_TILE_SIZE; |
| |
| res = CreateRTSurface(width,height, |
| (format != D3DFMT_A8R8G8B8), TRUE /*lockable*/, |
| &format, &pLockableRTSurface); |
| *ppSurfaceResource = pLockableRTSurface; |
| |
| return res; |
| } |
| |
| HRESULT |
| D3DResourceManager::GetCachedDestTexture(D3DFORMAT format, |
| D3DResource **ppTextureResource) |
| { |
| J2dTraceLn(J2D_TRACE_INFO, "D3DRM::GetCachedDestTexture"); |
| |
| RETURN_STATUS_IF_NULL(pCtx, E_FAIL); |
| RETURN_STATUS_IF_NULL(ppTextureResource, E_FAIL); |
| |
| HRESULT res = |
| GetStockTextureResource(D3DTR_CACHED_DEST_WIDTH, |
| D3DTR_CACHED_DEST_HEIGHT, |
| TRUE/*isRTT*/, FALSE/*isOpaque*/, |
| &format, 0, &pCachedDestTexture); |
| if (SUCCEEDED(res)) { |
| D3DSURFACE_DESC *pDesc = pCachedDestTexture->GetDesc(); |
| D3DCAPS9 *pDevCaps = pCtx->GetDeviceCaps(); |
| if ((format == pDesc->Format || |
| SUCCEEDED(pCtx->Get3DObject()->CheckDeviceFormatConversion( |
| pDevCaps->AdapterOrdinal, |
| pDevCaps->DeviceType, format, pDesc->Format)))) |
| { |
| *ppTextureResource = pCachedDestTexture; |
| return res; |
| } |
| // current texture doesn't fit, release and allocate a new one |
| ReleaseResource(pCachedDestTexture); |
| pCachedDestTexture = NULL; |
| } |
| res = CreateTexture(D3DTR_CACHED_DEST_WIDTH, D3DTR_CACHED_DEST_HEIGHT, |
| TRUE, FALSE, &format, 0, |
| &pCachedDestTexture); |
| *ppTextureResource = pCachedDestTexture; |
| return res; |
| } |
| |
| HRESULT |
| D3DResourceManager::GetStockTextureResource(UINT width, UINT height, |
| BOOL isRTT, BOOL isOpaque, |
| D3DFORMAT *pFormat/*in/out*/, |
| DWORD dwUsage, |
| D3DResource **ppTextureResource) |
| { |
| D3DResource *pResource = *ppTextureResource; |
| if (pResource != NULL) { |
| if (pResource->GetTexture() != NULL) { |
| return S_OK; |
| } |
| ReleaseResource(pResource); |
| *ppTextureResource = NULL; |
| } |
| |
| return CreateTexture(width, height, isRTT, isOpaque, pFormat, dwUsage, |
| ppTextureResource); |
| } |
