void set_synchronization(bool enable) //TODO: Needs to be rewritten { if (d3dmgr == NULL) { return; } IDirect3DSwapChain9 *sc; d3dmgr->GetSwapChain(0, &sc); D3DPRESENT_PARAMETERS d3dpp; sc->GetPresentParameters(&d3dpp); if (enable) { d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT; //Present the frame immediately } else { d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; //Present the frame immediately } sc->Release(); d3dmgr->Reset(&d3dpp); }
void _stdcall ProxyDevice::GetGammaRamp(D3DGAMMARAMP *a) { IDirect3DSwapChain9 *sc; D3DPRESENT_PARAMETERS pp; realDevice->GetSwapChain(0, &sc); sc->GetPresentParameters(&pp); sc->Release(); if(pp.Windowed) GetDeviceGammaRamp(GetDC(pp.hDeviceWindow), (void*)a); else realDevice->GetGammaRamp(0, a); }
void WindowResized() { if (d3dmgr == NULL) { return; } IDirect3DSwapChain9 *sc; d3dmgr->GetSwapChain(0, &sc); D3DPRESENT_PARAMETERS d3dpp; sc->GetPresentParameters(&d3dpp); int ww = window_get_width(), wh = window_get_height(); d3dpp.BackBufferWidth = ww <= 0 ? 1 : ww; d3dpp.BackBufferHeight = wh <= 0 ? 1 : wh; sc->Release(); OnDeviceLost(); d3dmgr->Reset(&d3dpp); OnDeviceReset(); // clear the window color, viewport does not need set because backbuffer was just recreated enigma_user::draw_clear(enigma_user::window_get_color()); }
//----------------------------------------------------------------------------- bool D3D9StereoDriverAMD::getPresentParamsAndVerifyStereoSettings() { // Verify the swap chain exists UINT numberOfSwapChains = mDevice->GetNumberOfSwapChains(); if (numberOfSwapChains < 0) return false; // Get the first swap chain IDirect3DSwapChain9* swapChain = NULL; if (FAILED(mDevice->GetSwapChain(0, &swapChain))) return false; // Cache the swap chain presentation parameters and release the swap chain swapChain->GetPresentParameters(&mSwapChainPresentParameters); swapChain->Release(); // Check if multi sample type must be set to a value greater than 1 to enable stereo if (D3DMULTISAMPLE_NONE == mSwapChainPresentParameters.MultiSampleType || D3DMULTISAMPLE_NONMASKABLE == mSwapChainPresentParameters.MultiSampleType) return false; return true; }
static bool d3d9_get_swap_desc(D3DPRESENT_PARAMETERS &pp) { IDirect3DSwapChain9 *swap = nullptr; HRESULT hr; hr = data.device->GetSwapChain(0, &swap); if (FAILED(hr)) { hlog_hr("d3d9_get_swap_desc: Failed to get swap chain", hr); return false; } hr = swap->GetPresentParameters(&pp); swap->Release(); if (FAILED(hr)) { hlog_hr("d3d9_get_swap_desc: Failed to get " "presentation parameters", hr); return false; } return true; }
void display_reset(int samples, bool vsync) { if (d3dmgr == NULL) { return; } IDirect3DSwapChain9 *sc; d3dmgr->GetSwapChain(0, &sc); D3DPRESENT_PARAMETERS d3dpp; sc->GetPresentParameters(&d3dpp); if (vsync) { d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT; //Present the frame immediately } else { d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; //Present the frame immediately } d3dpp.MultiSampleType = (D3DMULTISAMPLE_TYPE)((int)D3DMULTISAMPLE_NONE + samples); // Levels of multi-sampling d3dpp.MultiSampleQuality = 0; //No multi-sampling if (samples) { d3dmgr->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, TRUE); } else { d3dmgr->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, FALSE); } sc->Release(); enigma::OnDeviceLost(); d3dmgr->Reset(&d3dpp); enigma::OnDeviceReset(); }
//Given device to draw to, see if we already have it cached and if not, cache it. //Also check if we have switched mode (i.e. we were windowed and this device is //a fullscreen device, or we were full-screen and this is a windowed one). void CFSXGUI::CheckIfNewDevice(IDirect3DDevice9 *pI) { if (!pI) return; //Check if already have it bool bAlreadyHave = false; if (m_WindowedDeviceDesc.pDevice == pI) bAlreadyHave = true; else for (size_t i = 0; !bAlreadyHave && i < m_aFullscreenDevices.size(); i++) { if (m_aFullscreenDevices[i].pDevice == pI) bAlreadyHave = true; } //If we don't have it, determine if it's windowed or full-screen device and cache it if (!bAlreadyHave) { IDirect3DSwapChain9 *pISwapChain; if (FAILED(pI->GetSwapChain(0, &pISwapChain))) return; D3DPRESENT_PARAMETERS PP; if (FAILED(pISwapChain->GetPresentParameters(&PP))) { pISwapChain->Release(); return; } pISwapChain->Release(); //Windowed? if (PP.Windowed) { //There is only one windowed device, so we don't cache it. Also since we're presenting //on one, we must be in windowed mode. m_WindowedDeviceDesc.hWnd = PP.hDeviceWindow; //should always be m_hFSXWin? m_WindowedDeviceDesc.pDevice = pI; m_pFullscreenPrimaryDevice = nullptr; if (!m_bInWindowedMode) { m_bInWindowedMode = true; NotifyDialogsNowWindowed(PP.hDeviceWindow); } } //Fullscreen -- add to list. else { static DeviceDescStruct D; D.hWnd = PP.hDeviceWindow; D.pDevice = pI; m_aFullscreenDevices.push_back(D); //Currently only draw to device associated with FSX's main window (primary screen on multi-monitor setups). //We cache the other devices in case we want to drag to other monitors in fullscreen mode, someday. if (PP.hDeviceWindow == m_hFSXWindow) { m_pFullscreenPrimaryDevice = pI; m_bInWindowedMode = false; m_WindowedDeviceDesc.pDevice = nullptr; //no longer valid (FSX likely deletes it) NotifyDialogsNowFullscreen(pI, PP.BackBufferWidth, PP.BackBufferHeight); } } } return; }
bool OculusVR::OnPresent_Direct3D9(IDirect3DDevice9* device) { const CHAR* head = "OculusVR::OnPresent_Direct3D9"; if (Renderer == nullptr) { Renderer = new Direct3D11Helper(EDirect3D::DXGI0, device); if (Renderer == nullptr) { LVMSG(head, "alloc renderer object failed"); return false; } } if (device != nullptr) { IDirect3DSwapChain9* swapChain = nullptr; D3DPRESENT_PARAMETERS params; if (FAILED(device->GetSwapChain(0, &swapChain)) || FAILED(swapChain->GetPresentParameters(¶ms))) { LVERROR(head, "get target window from direct9 device failed"); return false; } SGlobalSharedDataInst.SetTargetWindow(params.hDeviceWindow); SAFE_RELEASE(swapChain); } if (!EnsureInitialized(Renderer->GetSwapChain(), false)) { return false; } if (!Renderer->UpdateBuffer_Direct3D9(device)) { LVMSG(head, "update buffer with direct9 device failed"); return false; } //{ // if (RTV == nullptr) // { // if (Renderer->CreateRenderTargetView(Renderer->GetBufferDirect3D9Copy(), &RTV)) // { // return false; // } // } // RenderStateCache cache(Renderer->GetContext()); // cache.Capture(); // D3D11_VIEWPORT vp; // vp.TopLeftX = Layer[0]->EyeRenderViewport[0].Pos.x; // vp.TopLeftY = Layer[0]->EyeRenderViewport[0].Pos.y; // vp.Width = Layer[0]->EyeRenderViewport[0].Size.w; // vp.Height = Layer[0]->EyeRenderViewport[0].Size.h; // vp.MinDepth = 0.01f; // vp.MaxDepth = 10000.f; // Renderer->GetContext()->RSSetViewports(1, &vp); // Renderer->GetContext()->OMSetRenderTargets(1, &RTV, nullptr); // Renderer->UpdateCursor(LVVec3(2.f, 2.f, -1.f), 0.1f, DirectX::XMMatrixIdentity(), DirectX::XMMatrixIdentity(), // SGlobalSharedDataInst.GetBDrawCursor()); // cache.Restore(); //} Layer[0]->GetEyePoses(); ID3D11Texture2D* dst = Layer[0]->pEyeRenderTexture[0]->GetBuffer(); if (!Renderer->OutputBuffer_Texture2D_Direct3D9(dst)) { return false; } Layer[0]->Commit(0); ovrResult ret = DistortAndPresent(1); if (!OVR_SUCCESS(ret)) { //LVERROR(head, "submit failed(%d), ...", ret); return false; } return true; }
HRESULT WINAPI D3D9Present(IDirect3DDevice9 *pDev, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion) { D3D9FrameGrabber *d3d9FrameGrabber = D3D9FrameGrabber::getInstance(); Logger *logger = d3d9FrameGrabber->m_logger; DWORD errorcode; if (WAIT_OBJECT_0 == (errorcode = WaitForSingleObject(d3d9FrameGrabber->m_syncRunMutex, 0))) { IPCContext *ipcContext = d3d9FrameGrabber->m_ipcContext; logger->reportLogDebug(L"D3D9Present"); HRESULT hRes; RECT newRect = RECT(); IDirect3DSurface9 *pBackBuffer = NULL; IDirect3DSurface9 *pDemultisampledSurf = NULL; IDirect3DSurface9 *pOffscreenSurf = NULL; IDirect3DSwapChain9 *pSc = NULL; D3DPRESENT_PARAMETERS params; if(FAILED( hRes = pDev->GetSwapChain(0, &pSc))) { logger->reportLogError(L"d3d9present couldn't get swapchain. result 0x%x", hRes); goto end; } hRes = pSc->GetPresentParameters(¶ms); if (FAILED(hRes) || params.Windowed) { goto end; } if(FAILED( hRes = pDev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer))) { goto end; } D3DSURFACE_DESC surfDesc; pBackBuffer->GetDesc(&surfDesc); hRes = pDev->CreateRenderTarget( surfDesc.Width, surfDesc.Height, surfDesc.Format, D3DMULTISAMPLE_NONE, 0, false, &pDemultisampledSurf, NULL ); if (FAILED(hRes)) { logger->reportLogError(L"GetFramePrep: FAILED to create demultisampled render target. 0x%x, width=%u, height=%u, format=%x", hRes, surfDesc.Width, surfDesc.Height, surfDesc.Format ); goto end; } hRes = pDev->StretchRect(pBackBuffer, NULL, pDemultisampledSurf, NULL, D3DTEXF_LINEAR ); if (FAILED(hRes)) { logger->reportLogError(L"GetFramePrep: StretchRect FAILED for image surfacee. 0x%x, width=%u, height=%u, format=%x", hRes, surfDesc.Width, surfDesc.Height, surfDesc.Format ); goto end; } hRes = pDev->CreateOffscreenPlainSurface( surfDesc.Width, surfDesc.Height, surfDesc.Format, D3DPOOL_SYSTEMMEM, &pOffscreenSurf, NULL ); if (FAILED(hRes)) { logger->reportLogError(L"GetFramePrep: FAILED to create image surface. 0x%x, width=%u, height=%u, format=%x", hRes, surfDesc.Width, surfDesc.Height, surfDesc.Format ); goto end; } hRes = pDev->GetRenderTargetData(pDemultisampledSurf, pOffscreenSurf ); if (FAILED(hRes)) { logger->reportLogError(L"GetFramePrep: GetRenderTargetData() FAILED for image surfacee. 0x%x, width=%u, height=%u, format=%x", hRes, surfDesc.Width, surfDesc.Height, surfDesc.Format ); goto end; } D3DLOCKED_RECT lockedSrcRect; newRect.right = surfDesc.Width; newRect.bottom = surfDesc.Height; hRes = pOffscreenSurf->LockRect( &lockedSrcRect, &newRect, 0); if (FAILED(hRes)) { logger->reportLogError(L"GetFramePrep: FAILED to lock source rect. (0x%x)", hRes ); goto end; } ipcContext->m_memDesc.width = surfDesc.Width; ipcContext->m_memDesc.height = surfDesc.Height; ipcContext->m_memDesc.rowPitch = lockedSrcRect.Pitch; ipcContext->m_memDesc.frameId++; ipcContext->m_memDesc.format = getCompatibleBufferFormat(surfDesc.Format); DWORD errorcode; if (WAIT_OBJECT_0 == (errorcode = WaitForSingleObject(ipcContext->m_hMutex, 0))) { // reportLog(EVENTLOG_INFORMATION_TYPE, L"d3d9 writing description to mem mapped file"); memcpy(ipcContext->m_pMemMap, &(ipcContext->m_memDesc), sizeof (ipcContext->m_memDesc)); // reportLog(EVENTLOG_INFORMATION_TYPE, L"d3d9 writing data to mem mapped file"); PVOID pMemDataMap = incPtr(ipcContext->m_pMemMap, sizeof (ipcContext->m_memDesc)); if (static_cast<UINT>(lockedSrcRect.Pitch) == surfDesc.Width * 4) { memcpy(pMemDataMap, lockedSrcRect.pBits, surfDesc.Width * surfDesc.Height * 4); } else { UINT i = 0, cleanOffset = 0, pitchOffset = 0; while (i < surfDesc.Height) { memcpy(incPtr(pMemDataMap, cleanOffset), incPtr(lockedSrcRect.pBits, pitchOffset), surfDesc.Width * 4); cleanOffset += surfDesc.Width * 4; pitchOffset += lockedSrcRect.Pitch; i++; } } ReleaseMutex(ipcContext->m_hMutex); SetEvent(ipcContext->m_hFrameGrabbedEvent); } else { logger->reportLogError(L"d3d9 couldn't wait mutex. errocode = 0x%x", errorcode); } end: if(pOffscreenSurf) pOffscreenSurf->Release(); if(pDemultisampledSurf) pDemultisampledSurf->Release(); if(pBackBuffer) pBackBuffer->Release(); if(pSc) pSc->Release(); ProxyFuncJmp *d3d9PresentProxyFuncJmp = d3d9FrameGrabber->m_d3d9PresentProxyFuncJmp; if(!d3d9PresentProxyFuncJmp->removeHook()) { int i = GetLastError(); logger->reportLogError(L"d3d9 error occured while trying to removeHook before original call0x%x", i); } HRESULT result = pDev->Present(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion); if(!d3d9PresentProxyFuncJmp->installHook()) { int i = GetLastError(); logger->reportLogError(L"d3d9 error occured while trying to installHook after original call0x%x", i); } ReleaseMutex(d3d9FrameGrabber->m_syncRunMutex); return result; } else { logger->reportLogError(L"d3d9sc present is skipped because mutex is busy"); return S_FALSE; } }