VirtualBox

Ignore:
Timestamp:
Sep 20, 2010 10:36:25 AM (14 years ago)
Author:
vboxsync
Message:

wddm/3d: display resize when aero is on (autoresize not working with aero yet)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp

    r32580 r32632  
    18371837            {
    18381838                IDirect3DSurface9 *pD3D9OldSurf = (IDirect3DSurface9*)pAlloc->pD3DIf;
    1839                 if (pD3D9OldSurf)
    1840                 {
    1841                     VOID *pvSwapchain = NULL;
    1842                     HRESULT tmpHr = pD3D9OldSurf->GetContainer(IID_IDirect3DSwapChain9, &pvSwapchain);
    1843                     if (tmpHr != S_OK || pvSwapchain != ((IDirect3DSwapChain9 *)pSwapchain->pSwapChainIf))
    1844                     {
    1845                         hr = pDevice->pDevice9If->StretchRect(pD3D9OldSurf, NULL, pD3D9Surf, NULL, D3DTEXF_NONE);
    1846                         Assert(hr == S_OK);
    1847                     }
     1839                if (pD3D9OldSurf && pD3D9OldSurf != pD3D9Surf)
     1840                {
     1841                    Assert(0);
     1842                    hr = pDevice->pDevice9If->StretchRect(pD3D9OldSurf, NULL, pD3D9Surf, NULL, D3DTEXF_NONE);
     1843                    Assert(hr == S_OK);
    18481844                }
    18491845            }
    … …  
    18711867{
    18721868    HRESULT hr = S_OK;
    1873     for (int iBb = -1; iBb < int(pSwapchain->cRTs - 1); ++iBb)
    1874     {
    1875         hr = vboxWddmSwapchainRtSynch(pDevice, pSwapchain, (UINT)iBb);
     1869    if (pSwapchain->cRTs > 1)
     1870    {
     1871        for (int iBb = -1; iBb < int(pSwapchain->cRTs - 1); ++iBb)
     1872        {
     1873            hr = vboxWddmSwapchainRtSynch(pDevice, pSwapchain, (UINT)iBb);
     1874            Assert(hr == S_OK);
     1875        }
     1876    }
     1877    else
     1878    {
     1879        /* work-around wine backbuffer */
     1880        hr = vboxWddmSwapchainRtSynch(pDevice, pSwapchain, 0);
    18761881        Assert(hr == S_OK);
    18771882    }
    … …  
    19091914    /* preserve the old one */
    19101915    IDirect3DSwapChain9 * pOldIf = pSwapchain->pSwapChainIf;
    1911     /* first create the new one */
     1916    HRESULT hr = S_OK;
     1917    BOOL bReuseSwapchain = FALSE;
    19121918    D3DPRESENT_PARAMETERS Params;
    19131919    vboxWddmSwapchainFillParams(pSwapchain, &Params);
     1920    /* check if we need to re-create the swapchain */
     1921    if (pOldIf)
     1922    {
     1923        D3DPRESENT_PARAMETERS OldParams;
     1924        hr = pOldIf->GetPresentParameters(&OldParams);
     1925        Assert(hr == S_OK);
     1926        if (hr == S_OK)
     1927        {
     1928            if (OldParams.BackBufferCount == Params.BackBufferCount)
     1929            {
     1930                bReuseSwapchain = TRUE;
     1931            }
     1932        }
     1933    }
     1934
     1935  /* first create the new one */
    19141936    IDirect3DSwapChain9 * pNewIf;
    19151937    ///
    19161938    PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
    19171939    UINT cSurfs = pSwapchain->cRTs;
    1918     HRESULT hr = S_OK;
    19191940    IDirect3DDevice9 *pDevice9If = NULL;
    19201941    HWND hOldWnd = pSwapchain->hWnd;
     1942    if (!bReuseSwapchain)
     1943    {
    19211944//#define VBOXDISP_NEWWND_ON_SWAPCHAINUPDATE
    19221945#ifndef VBOXDISP_NEWWND_ON_SWAPCHAINUPDATE
    1923     if (!hOldWnd)
     1946        if (!hOldWnd)
    19241947#endif
    1925     {
    1926         hr = VBoxDispWndCreate(pAdapter, Params.BackBufferWidth, Params.BackBufferHeight, &pSwapchain->hWnd);
    1927         Assert(hr == S_OK);
    1928     }
    1929     if (hr == S_OK)
    1930     {
    1931         DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
    1932         if (pDevice->fFlags.AllowMultithreading)
    1933             fFlags |= D3DCREATE_MULTITHREADED;
    1934 
    1935         Params.hDeviceWindow = pSwapchain->hWnd;
    1936                     /* @todo: it seems there should be a way to detect this correctly since
    1937                      * our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
    1938         Params.Windowed = TRUE;
    1939         //            params.EnableAutoDepthStencil = FALSE;
    1940         //            params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
    1941         //            params.Flags;
    1942         //            params.FullScreen_RefreshRateInHz;
    1943         //            params.FullScreen_PresentationInterval;
    1944         if (!pDevice->pDevice9If)
    1945         {
    1946             hr = pAdapter->pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, pSwapchain->hWnd, fFlags, &Params, &pDevice9If);
     1948        {
     1949            hr = VBoxDispWndCreate(pAdapter, Params.BackBufferWidth, Params.BackBufferHeight, &pSwapchain->hWnd);
    19471950            Assert(hr == S_OK);
    1948             if (hr == S_OK)
    1949             {
    1950                 pDevice->pDevice9If = pDevice9If;
    1951                 hr = pDevice9If->GetSwapChain(0, &pNewIf);
     1951        }
     1952        if (hr == S_OK)
     1953        {
     1954            DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
     1955            if (pDevice->fFlags.AllowMultithreading)
     1956                fFlags |= D3DCREATE_MULTITHREADED;
     1957
     1958            Params.hDeviceWindow = pSwapchain->hWnd;
     1959                        /* @todo: it seems there should be a way to detect this correctly since
     1960                         * our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
     1961            Params.Windowed = TRUE;
     1962            //            params.EnableAutoDepthStencil = FALSE;
     1963            //            params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
     1964            //            params.Flags;
     1965            //            params.FullScreen_RefreshRateInHz;
     1966            //            params.FullScreen_PresentationInterval;
     1967            if (!pDevice->pDevice9If)
     1968            {
     1969                hr = pAdapter->pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, pSwapchain->hWnd, fFlags, &Params, &pDevice9If);
    19521970                Assert(hr == S_OK);
    19531971                if (hr == S_OK)
    19541972                {
     1973                    pDevice->pDevice9If = pDevice9If;
     1974                    hr = pDevice9If->GetSwapChain(0, &pNewIf);
     1975                    Assert(hr == S_OK);
     1976                    if (hr == S_OK)
     1977                    {
     1978                        Assert(pNewIf);
     1979                    }
     1980                    else
     1981                    {
     1982                        pDevice9If->Release();
     1983                    }
     1984                }
     1985            }
     1986            else
     1987            {
     1988                pDevice9If = pDevice->pDevice9If;
     1989                hr = pDevice->pDevice9If->CreateAdditionalSwapChain(&Params, &pNewIf);
     1990                Assert(hr == S_OK);
     1991                if (hr == S_OK)
     1992                {
    19551993                    Assert(pNewIf);
    19561994                }
    1957                 else
    1958                 {
    1959                     pDevice9If->Release();
    1960                 }
    1961             }
    1962         }
    1963         else
    1964         {
    1965             pDevice9If = pDevice->pDevice9If;
    1966             hr = pDevice->pDevice9If->CreateAdditionalSwapChain(&Params, &pNewIf);
    1967             Assert(hr == S_OK);
    1968             if (hr == S_OK)
    1969             {
    1970                 Assert(pNewIf);
    1971             }
    1972         }
    1973 
    1974         if (hr == S_OK)
    1975         {
    1976             Assert(pNewIf);
    1977             pSwapchain->pSwapChainIf = pNewIf;
     1995            }
     1996        }
     1997    }
     1998    else
     1999    {
     2000        Assert(pOldIf);
     2001        Assert(hOldWnd);
     2002        pNewIf = pOldIf;
     2003        /* to ensure the swapchain is not deleted once we release the pOldIf */
     2004        pNewIf->AddRef();
     2005    }
     2006
     2007    if (hr == S_OK)
     2008    {
     2009        Assert(pNewIf);
     2010        pSwapchain->pSwapChainIf = pNewIf;
    19782011#ifndef VBOXWDDM_WITH_VISIBLE_FB
    1979             if (!pSwapchain->pRenderTargetFbCopy)
    1980             {
    1981                 IDirect3DSurface9* pD3D9Surf;
    1982                 hr = pDevice9If->CreateRenderTarget(
     2012        if (!pSwapchain->pRenderTargetFbCopy)
     2013        {
     2014            IDirect3DSurface9* pD3D9Surf;
     2015            hr = pDevice9If->CreateRenderTarget(
    19832016                                    Params.BackBufferWidth, Params.BackBufferHeight,
    19842017                                    Params.BackBufferFormat,
    … …  
    19892022                                    NULL /* HANDLE* pSharedHandle */
    19902023                                    );
     2024            Assert(hr == S_OK);
     2025            if (hr == S_OK)
     2026            {
     2027                Assert(pD3D9Surf);
     2028                pSwapchain->pRenderTargetFbCopy = pD3D9Surf;
     2029            }
     2030        }
     2031#endif
     2032
     2033        if (hr == S_OK)
     2034        {
     2035            for (UINT i = 0; i < cSurfs; ++i)
     2036            {
     2037                PVBOXWDDMDISP_RENDERTGT pRt = &pSwapchain->aRTs[i];
     2038                pRt->pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
     2039            }
     2040
     2041            hr = vboxWddmSwapchainSynch(pDevice, pSwapchain);
     2042            Assert(hr == S_OK);
     2043            if (hr == S_OK)
     2044            {
     2045                for (UINT i = 0; i < cSurfs; ++i)
     2046                {
     2047                    PVBOXWDDMDISP_RENDERTGT pRt = &pSwapchain->aRTs[i];
     2048                    hr = vboxWddmSurfSynchMem(pRt->pAlloc->pRc, pRt->pAlloc);
     2049                    Assert(hr == S_OK);
     2050                    if (hr != S_OK)
     2051                    {
     2052                        break;
     2053                    }
     2054                }
     2055
    19912056                Assert(hr == S_OK);
    19922057                if (hr == S_OK)
    19932058                {
    1994                     Assert(pD3D9Surf);
    1995                     pSwapchain->pRenderTargetFbCopy = pD3D9Surf;
    1996                 }
    1997             }
    1998 #endif
    1999 
    2000             if (hr == S_OK)
    2001             {
    2002                 for (UINT i = 0; i < cSurfs; ++i)
    2003                 {
    2004                     PVBOXWDDMDISP_RENDERTGT pRt = &pSwapchain->aRTs[i];
    2005                     pRt->pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
    2006                 }
    2007 
    2008                 hr = vboxWddmSwapchainSynch(pDevice, pSwapchain);
    2009                 Assert(hr == S_OK);
    2010                 if (hr == S_OK)
    2011                 {
    2012                     for (UINT i = 0; i < cSurfs; ++i)
     2059                    Assert(pSwapchain->fFlags.Value == 0);
     2060                    if (pOldIf)
    20132061                    {
    2014                         PVBOXWDDMDISP_RENDERTGT pRt = &pSwapchain->aRTs[i];
    2015                         hr = vboxWddmSurfSynchMem(pRt->pAlloc->pRc, pRt->pAlloc);
    2016                         Assert(hr == S_OK);
    2017                         if (hr != S_OK)
     2062                        Assert(hOldWnd);
     2063                        pOldIf->Release();
     2064                        if (hOldWnd != pSwapchain->hWnd)
    20182065                        {
    2019                             break;
     2066                            VBoxDispWndDestroy(pAdapter, hOldWnd);
    20202067                        }
    20212068                    }
    2022 
    2023                     Assert(hr == S_OK);
    2024                     if (hr == S_OK)
     2069                    else
    20252070                    {
    2026                         Assert(pSwapchain->fFlags.Value == 0);
    2027                         if (pOldIf)
    2028                         {
    2029                             Assert(hOldWnd);
    2030                             pOldIf->Release();
    2031 #ifdef VBOXDISP_NEWWND_ON_SWAPCHAINUPDATE
    2032                             VBoxDispWndDestroy(pAdapter, hOldWnd);
    2033 #endif
    2034                         }
    2035                         else
    2036                         {
    2037                             Assert(!hOldWnd);
    2038                         }
    2039                         return S_OK;
     2071                        Assert(!hOldWnd);
    20402072                    }
     2073                    return S_OK;
    20412074                }
    20422075            }
    … …  
    20462079
    20472080        Assert(hr != S_OK);
    2048 #ifndef VBOXDISP_NEWWND_ON_SWAPCHAINUPDATE
    2049         if (!hOldWnd)
    2050 #endif
     2081        if (hOldWnd != pSwapchain->hWnd)
    20512082        {
    20522083            HRESULT tmpHr = VBoxDispWndDestroy(pAdapter, pSwapchain->hWnd);
    … …  
    50835114                vboxWddmSwapchainRtRemove(pSwapchain, pRt);
    50845115                Assert(!vboxWddmSwapchainForAlloc(pAlloc));
     5116                if (!vboxWddmSwapchainNumRTs(pSwapchain))
     5117                    vboxWddmSwapchainDestroy(pDevice, pSwapchain);
    50855118            }
    50865119
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette