able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/directx/dxg/d3d8/fw/swapchan.cpp

2317 lines
73 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//=============================================================================
// Copyright (c) 1999 Microsoft Corporation
//
// swapchan.cpp
//
// Direct3D swap chain implementation.
//
// Created 11/16/1999 johnstep (John Stephens)
//=============================================================================
#include "ddrawpr.h"
#include "swapchan.hpp"
#include "pixel.hpp"
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::QueryInterface"
//=============================================================================
// IUnknown::QueryInterface (public)
//
// Created 11/16/1999 johnstep
//=============================================================================
STDMETHODIMP
CSwapChain::QueryInterface(
REFIID riid,
void **ppInterface
)
{
API_ENTER(Device());
if (!VALID_PTR_PTR(ppInterface))
{
DPF_ERR("Invalid ppvObj parameter passed to QueryInterface for a SwapChain");
return D3DERR_INVALIDCALL;
}
if (!VALID_PTR(&riid, sizeof(GUID)))
{
DPF_ERR("Invalid guid memory address to QueryInterface for a SwapChain");
return D3DERR_INVALIDCALL;
}
if ((riid == IID_IDirect3DSwapChain8) || (riid == IID_IUnknown))
{
AddRef();
*ppInterface =
static_cast<void *>(
static_cast<IDirect3DSwapChain8 *>(this));
return S_OK;
}
DPF_ERR("Unsupported Interface identifier passed to QueryInterface for a SwapChain");
// Null out param
*ppInterface = NULL;
return E_NOINTERFACE;
} // QueryInterface
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::AddRef"
//=============================================================================
// IUnknown::AddRef (public)
//
// Created 11/16/1999 johnstep
//=============================================================================
STDMETHODIMP_(ULONG)
CSwapChain::AddRef()
{
API_ENTER_NO_LOCK(Device());
return AddRefImpl();
} // AddRef
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::Release"
//=============================================================================
// IUnknown::Release (public)
//
// Created 11/16/1999 johnstep
//=============================================================================
STDMETHODIMP_(ULONG)
CSwapChain::Release()
{
API_ENTER_SUBOBJECT_RELEASE(Device());
return ReleaseImpl();
} // Release
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::CSwapChain"
//=============================================================================
// CSwapChain::CSwapChain
//
// Created 11/16/1999 johnstep
//=============================================================================
CSwapChain::CSwapChain(
CBaseDevice *pDevice,
REF_TYPE refType) :
CBaseObject(pDevice, refType),
m_pCursor(NULL),
m_hGDISurface(NULL),
m_pMirrorSurface(NULL),
m_pPrimarySurface(NULL),
m_ppBackBuffers(NULL),
m_presentnext(0),
m_cBackBuffers(0),
m_bExclusiveMode(FALSE),
m_pCursorShadow(NULL),
m_pHotTracking(NULL),
m_lIMEState(0),
m_lSetIME(0),
m_dwFlags(0),
m_dwFlipCnt(0),
m_dwFlipTime(0xffffffff),
m_uiErrorMode(0)
{
HKEY hKey;
ZeroMemory(&m_BltData, sizeof m_BltData);
m_BltData.hDD = Device()->GetHandle();
m_BltData.bltFX.dwROP = SRCCOPY;
m_BltData.ddRVal = E_FAIL;
if (!RegOpenKey(HKEY_LOCAL_MACHINE, RESPATH_D3D, &hKey))
{
DWORD type;
DWORD value;
DWORD cb = sizeof(value);
if (!RegQueryValueEx(hKey, REGSTR_VAL_DDRAW_SHOWFRAMERATE, NULL, &type, (CONST LPBYTE)&value, &cb))
{
DPF( 2, REGSTR_VAL_DDRAW_SHOWFRAMERATE" : %d", value );
if (value)
{
m_dwFlags |= D3D_REGFLAGS_SHOWFRAMERATE;
}
}
#ifdef WINNT
cb = sizeof(value);
if (!RegQueryValueEx(hKey, REGSTR_VAL_D3D_FLIPNOVSYNC, NULL, &type, (CONST LPBYTE)&value, &cb))
{
DPF( 2, REGSTR_VAL_D3D_FLIPNOVSYNC" : %d", value );
if (value)
{
m_dwFlags |= D3D_REGFLAGS_FLIPNOVSYNC;
}
}
RegCloseKey(hKey);
}
m_dwForceRefreshRate = 0;
if( !RegOpenKey( HKEY_LOCAL_MACHINE, REGSTR_PATH_DDRAW, &hKey ) )
{
DWORD type;
DWORD value;
DWORD cb = sizeof(value);
if( !RegQueryValueEx( hKey, REGSTR_VAL_DDRAW_FORCEREFRESHRATE, NULL, &type, (CONST LPBYTE)&value, &cb ) )
{
m_dwForceRefreshRate = value;
}
#endif
RegCloseKey(hKey);
}
}
void CSwapChain::Init(
D3DPRESENT_PARAMETERS* pPresentationParams,
HRESULT *pHr
)
{
DXGASSERT(pHr != NULL);
//the gamma ramp is initialized to 1:1
for (int i=0;i<256;i++)
{
m_DesiredGammaRamp.red[i] =
m_DesiredGammaRamp.green[i] =
m_DesiredGammaRamp.blue[i] = static_cast<WORD>(i);
}
*pHr = Reset(
pPresentationParams);
return;
} // CSwapChain::CSwapChain
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::~CSwapChain"
//=============================================================================
// CSwapChain::~CSwapChain
//
// Created 11/16/1999 johnstep
//=============================================================================
CSwapChain::~CSwapChain()
{
if (!m_PresentationData.Windowed)
{
m_PresentationData.Windowed = TRUE;
// make sure we restore after a fullscreen
SetCooperativeLevel();
}
Destroy();
} // CSwapChain::~CSwapChain
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::CreateWindowed"
//=============================================================================
// CSwapChain::CreateWindowed
//
// Created 11/16/1999 johnstep
//=============================================================================
HRESULT
CSwapChain::CreateWindowed(
UINT width,
UINT height,
D3DFORMAT backBufferFormat,
UINT cBackBuffers,
D3DMULTISAMPLE_TYPE MultiSampleType,
BOOL bDiscard,
BOOL bLockable
)
{
// For the windowed case, we will currently create exactly 3 surfaces
// in this order:
//
// 1. Primary Surface
// 2. Back Buffer
// 3. Z Buffer (by notifying the device)
//
// For now, all 3 surfaces must reside in local video memory. Later,
// we may allow multiple back buffers, if there is interest, to allow
// simulated fullscreen-style double buffering (alternate back buffer
// surfaces after presenting).
//
// !!! The primary surface is actually optional because we can just use
// DdGetDC and then GDI BitBlt. But, presumably, there are performance
// advantages to using DirectDraw Blt. Of course, the problem with using
// DirectDraw Blts is keeping in sync with the window manager (so we
// don't write outside of the window, etc.). GDI BitBlt will also handle
// format conversion for us, though slowly.
DXGASSERT(m_pPrimarySurface == NULL);
DXGASSERT(m_ppBackBuffers == NULL);
DXGASSERT(m_cBackBuffers == 0);
HRESULT hr;
if (D3DSWAPEFFECT_FLIP == m_PresentationData.SwapEffect)
{
cBackBuffers = m_PresentationData.BackBufferCount + 1;
}
// 1. Create a simple primary surface. If we already have a primary
// surface, then don't bother to create a new one.
if (this == Device()->SwapChain())
{
DWORD dwUsage = D3DUSAGE_PRIMARYSURFACE | D3DUSAGE_LOCK;
DWORD Width = Device()->DisplayWidth();
DWORD Height = Device()->DisplayHeight();
// D3DSWAPEFFECT_NO_PRESENT is a hack to allow our D3D test framework
// to create a windowed REF device after they have created a fullscreen
// HAL device. We cannot create a second primary surface for the windowed
// device, but we cannot leave m_pPrimarySurface equal to NULL (becaue then
// we cannot cleanup the swap chain and Reset will fail), so instead we
// create a dummy surface and call it the primary, with the understanding
// that this device will never call Present or use the primary surface in
// any way. We also don't have to do much checking since this is not an
// external feature.
if (D3DSWAPEFFECT_NO_PRESENT == m_PresentationData.SwapEffect)
{
dwUsage = D3DUSAGE_OFFSCREENPLAIN | D3DUSAGE_LOCK;
Width = 256;
Height = 256;
}
m_pPrimarySurface = new CDriverSurface(
Device(),
Width,
Height,
dwUsage,
Device()->DisplayFormat(), // UserFormat
Device()->DisplayFormat(), // RealFormat
D3DMULTISAMPLE_NONE,//of course, when windowed
0, // hKernelHandle
REF_INTERNAL,
&hr);
}
else
{
// Additional SwapChain, it's already there
m_pPrimarySurface = Device()->SwapChain()->PrimarySurface();
hr = DD_OK;
}
// 2. Create the back buffer.
if (m_pPrimarySurface == NULL)
{
return E_OUTOFMEMORY;
}
m_PresentUseBlt = TRUE;
if (SUCCEEDED(hr))
{
if (m_ppBackBuffers = new CDriverSurface *[cBackBuffers])
{
DWORD Usage = D3DUSAGE_BACKBUFFER | D3DUSAGE_RENDERTARGET;
if ((D3DMULTISAMPLE_NONE == m_PresentationData.MultiSampleType) &&
bLockable)
{
Usage |= D3DUSAGE_LOCK;
}
if (bDiscard)
{
Usage |= D3DUSAGE_DISCARD;
}
for (; m_cBackBuffers < cBackBuffers; ++m_cBackBuffers)
{
m_ppBackBuffers[m_cBackBuffers] = new CDriverSurface(
Device(),
width,
height,
Usage,
backBufferFormat, // UserFormat
backBufferFormat, // RealFormat
MultiSampleType,
0, // hKernelHandle
REF_INTRINSIC,
&hr);
if (m_ppBackBuffers[m_cBackBuffers] == NULL)
{
hr = E_OUTOFMEMORY;
break;
}
if (FAILED(hr))
{
m_ppBackBuffers[m_cBackBuffers]->DecrementUseCount();
m_ppBackBuffers[m_cBackBuffers] = NULL;
break;
}
}
if (m_cBackBuffers == cBackBuffers)
{
m_BltData.hDestSurface = m_pPrimarySurface->KernelHandle();
m_BltData.dwFlags = DDBLT_WINDOWCLIP | DDBLT_ROP | DDBLT_WAIT | DDBLT_DX8ORHIGHER;
if (Device()->GetD3DCaps()->MaxStreams != 0)
{
m_BltData.dwFlags |= DDBLT_PRESENTATION;
}
if (D3DSWAPEFFECT_COPY_VSYNC == m_PresentationData.SwapEffect)
{
m_BltData.dwFlags |= DDBLT_COPYVSYNC;
// Need to let thunk layer know current refresh rate
if (Device()->DisplayRate() < 60)
{
// 60Hz = 16.666ms per frame
// 75Hz = 13.333ms
// 85Hz = 11.765ms
m_BltData.threshold = 13;
}
else
{
m_BltData.threshold = (DWORD)(1000.0f / (float)Device()->DisplayRate());
}
}
m_ClientWidth = 0; // windowed client is updated in present
m_ClientHeight = 0;
return hr;
}
// Something went wrong, so clean up now.
// 2. Destroy Back Buffers, if any.
while (m_cBackBuffers > 0)
{
m_ppBackBuffers[--m_cBackBuffers]->DecrementUseCount();
}
delete [] m_ppBackBuffers;
m_ppBackBuffers = NULL;
}
else
{
hr = E_OUTOFMEMORY;
}
}
// 1. Destroy Primary Surface.
if (this == Device()->SwapChain())
m_pPrimarySurface->DecrementUseCount();
m_pPrimarySurface = NULL;
return hr;
} // CreateWindowed
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::CreateFullScreen"
//=============================================================================
// CSwapChain::CreateFullscreen
//
// Created 11/16/1999 johnstep
//=============================================================================
HRESULT
CSwapChain::CreateFullscreen(
UINT width,
UINT height,
D3DFORMAT backBufferFormat,
UINT cBackBuffers,
UINT PresentationRate,
D3DMULTISAMPLE_TYPE MultiSampleType,
BOOL bDiscard,
BOOL bLockable
)
{
HRESULT hr = E_FAIL;
DWORD i;
BOOL bMirrorBufferCreated, bNoDDrawSupport;
UINT Usage = 0;
if (bLockable)
{
Usage |= D3DUSAGE_LOCK;
}
if (bDiscard)
{
Usage |= D3DUSAGE_DISCARD;
}
// If it's a hardware device, we want to create a primary surface and a
// number of backbuffers. We need to make this a single driver call,
// however, in order for everything to get attached correctly. Therefore,
// what we do is call the DDI to create the primary chain, and it will
// return the handles for each surface in the chain. After that, we
// will individually create each swap chain buffer, but we will supply
// it with the required handles rather than having it call the DDI itself.
// First, call the DDI to allocate the memory and the kernel handles
DDSURFACEINFO SurfInfoArray[D3DPRESENT_BACK_BUFFERS_MAX + 2];
ZeroMemory(SurfInfoArray, sizeof(SurfInfoArray));
D3D8_CREATESURFACEDATA CreateSurfaceData;
ZeroMemory(&CreateSurfaceData, sizeof(CreateSurfaceData));
DXGASSERT(cBackBuffers <= D3DPRESENT_BACK_BUFFERS_MAX);
for (i = 0; i < cBackBuffers + 1; i++)
{
SurfInfoArray[i].cpWidth = width;
SurfInfoArray[i].cpHeight = height;
}
CreateSurfaceData.hDD = Device()->GetHandle();
CreateSurfaceData.pSList = &SurfInfoArray[0];
bNoDDrawSupport = Device()->Enum()->NoDDrawSupport(Device()->AdapterIndex());
if (D3DDEVTYPE_HAL == Device()->GetDeviceType() &&
m_PresentationData.SwapEffect == D3DSWAPEFFECT_FLIP)
{
m_PresentUseBlt = FALSE;
bMirrorBufferCreated = FALSE;
CreateSurfaceData.dwSCnt = cBackBuffers + 1;
CreateSurfaceData.MultiSampleType = MultiSampleType;
}
else if ((m_PresentationData.SwapEffect == D3DSWAPEFFECT_COPY &&
m_PresentationData.FullScreen_PresentationInterval ==
D3DPRESENT_INTERVAL_IMMEDIATE) || bNoDDrawSupport
)
{
// If we're doing a copy-swap-effect and the app
// specifies interval-immediate, then we can blt directly
// to the primary without a mirror.
DXGASSERT(MultiSampleType == D3DMULTISAMPLE_NONE);
m_PresentUseBlt = TRUE;
bMirrorBufferCreated = FALSE;
CreateSurfaceData.dwSCnt = 1;
CreateSurfaceData.MultiSampleType = D3DMULTISAMPLE_NONE;
}
else
{
//one for m_pPrimarySurface and one for m_pMirrorSurface
m_PresentUseBlt = TRUE;
bMirrorBufferCreated = TRUE;
CreateSurfaceData.dwSCnt = 2;
CreateSurfaceData.MultiSampleType = D3DMULTISAMPLE_NONE;
}
CreateSurfaceData.Type = D3DRTYPE_SURFACE;
CreateSurfaceData.Pool = D3DPOOL_LOCALVIDMEM;
CreateSurfaceData.dwUsage = D3DUSAGE_PRIMARYSURFACE | Usage;
CreateSurfaceData.Format = Device()->DisplayFormat();
if(Device()->DisplayFormat() != backBufferFormat)
{
CreateSurfaceData.dwUsage |= D3DUSAGE_ALPHACHANNEL;
}
if (!bNoDDrawSupport)
{
hr = Device()->GetHalCallbacks()->CreateSurface(&CreateSurfaceData);
if (FAILED(hr))
{
if (D3DDEVTYPE_HAL == Device()->GetDeviceType())
{
DPF_ERR("Failed to create driver primary surface chain");
return hr;
}
else
{
// assume CreateSurfaceData is still intact
bMirrorBufferCreated = FALSE;
CreateSurfaceData.dwSCnt = 1;
hr = Device()->GetHalCallbacks()->CreateSurface(&CreateSurfaceData);
if (FAILED(hr))
{
DPF_ERR("Failed to create driver primary surface");
return hr;
}
}
}
}
// Now that we have the handles, create the surface interfaces
// one by one
// When creating passing in kernel handles to a driver
// surface, the surface will assume that it was created in
// LocalVidMem. We assert this here..
DXGASSERT(CreateSurfaceData.Pool == D3DPOOL_LOCALVIDMEM);
m_pPrimarySurface = new CDriverSurface(
Device(),
width,
height,
CreateSurfaceData.dwUsage | D3DUSAGE_LOCK,
// there is a problem with thunklayer when NoDDrawSupport
// DriverData.DisplayWidth and DriverData.DisplayHeight
// DriverData.DisplayFormat are not getting updated
// so we use backBufferFormat until Device()->DisplayFormat()
bNoDDrawSupport ? backBufferFormat : Device()->DisplayFormat(), // UserFormat
bNoDDrawSupport ? backBufferFormat : Device()->DisplayFormat(), // RealFormat
CreateSurfaceData.MultiSampleType,
SurfInfoArray[0].hKernelHandle,
REF_INTERNAL,
&hr);
if (m_pPrimarySurface == NULL)
{
// We'll clean up the kernel handle(s) at the
// end of the function
hr = E_OUTOFMEMORY;
}
else
{
// Zero out the kernel-handle so that
// we don't clean it at exit. If the CDriverSurface
// function fails; it will still release the kernel
// handle in its destructor.
SurfInfoArray[0].hKernelHandle = 0;
}
if (SUCCEEDED(hr))
{
m_hGDISurface = m_pPrimarySurface->KernelHandle();
if (bMirrorBufferCreated)
{
// Mirror surfaces are only useful if we're going
// to do a Blt as part of the Present. (We might
// also do a flip in addition.)
DXGASSERT(m_PresentUseBlt);
// When creating passing in kernel handles to a driver
// surface, the surface will assume that it was created in
// LocalVidMem. We assert this here..
DXGASSERT(CreateSurfaceData.Pool == D3DPOOL_LOCALVIDMEM);
m_pMirrorSurface = new CDriverSurface(
Device(),
width,
height,
D3DUSAGE_BACKBUFFER,
Device()->DisplayFormat(), // UserFormat
Device()->DisplayFormat(), // RealFormat
D3DMULTISAMPLE_NONE,
SurfInfoArray[1].hKernelHandle,
REF_INTERNAL,
&hr);
if (NULL == m_pMirrorSurface)
{
//if out of memory, then destroy the driver object as well
D3D8_DESTROYSURFACEDATA DestroySurfData;
DestroySurfData.hDD = Device()->GetHandle();
DestroySurfData.hSurface = SurfInfoArray[1].hKernelHandle;
Device()->GetHalCallbacks()->DestroySurface(&DestroySurfData);
bMirrorBufferCreated = FALSE;
hr = S_OK; //but don't fail as m_pMirrorSurface is optional
}
else if (FAILED(hr))
{
// Release the surface
m_pMirrorSurface->DecrementUseCount();
m_pMirrorSurface = NULL;
bMirrorBufferCreated = FALSE;
hr = S_OK; //but don't fail as m_pMirrorSurface is optional
}
else
{
//blt from m_ppBackBuffers[m_presentnext] to m_pMirrorSurface
//then flip from m_pPrimarySurface to m_pMirrorSurface
m_BltData.hDestSurface =
m_pMirrorSurface->KernelHandle();
}
// In all cases, zero out the kernel handle
// since it has either been owned by something or freed by now
SurfInfoArray[1].hKernelHandle = 0;
}
if (m_PresentUseBlt)
{
if (!bMirrorBufferCreated)
{
// If we're blitting and there is no
// mirror surface; then the primary must be
// the destination
DXGASSERT(m_BltData.hDestSurface == NULL);
m_BltData.hDestSurface = m_pPrimarySurface->KernelHandle();
}
if (D3DSWAPEFFECT_FLIP == m_PresentationData.SwapEffect)
{
// To emualte flip for SW drivers, create an extra backbuffer
cBackBuffers = m_PresentationData.BackBufferCount + 1;
}
ZeroMemory(SurfInfoArray, sizeof(SurfInfoArray));
for (i = 1; i < cBackBuffers + 1; i++)
{
SurfInfoArray[i].cpWidth = width;
SurfInfoArray[i].cpHeight = height;
}
ZeroMemory(&CreateSurfaceData, sizeof(CreateSurfaceData));
CreateSurfaceData.hDD = Device()->GetHandle();
CreateSurfaceData.pSList = &SurfInfoArray[1];
CreateSurfaceData.dwSCnt = cBackBuffers;
CreateSurfaceData.Type = D3DRTYPE_SURFACE;
CreateSurfaceData.Pool = D3DPOOL_DEFAULT;
CreateSurfaceData.dwUsage = D3DUSAGE_BACKBUFFER | D3DUSAGE_RENDERTARGET;
CreateSurfaceData.Format = backBufferFormat;
CreateSurfaceData.MultiSampleType = MultiSampleType;
hr = Device()->GetHalCallbacks()->CreateSurface(&CreateSurfaceData);
}
}
if (SUCCEEDED(hr))
{
if (m_ppBackBuffers = new CDriverSurface *[cBackBuffers])
{
DWORD Usage = D3DUSAGE_BACKBUFFER | D3DUSAGE_RENDERTARGET;
if ((D3DMULTISAMPLE_NONE == m_PresentationData.MultiSampleType) &&
bLockable)
{
Usage |= D3DUSAGE_LOCK;
}
for (; m_cBackBuffers < cBackBuffers; ++m_cBackBuffers)
{
m_ppBackBuffers[m_cBackBuffers] = new CDriverSurface(
Device(),
width,
height,
Usage,
backBufferFormat,
backBufferFormat,
MultiSampleType,
SurfInfoArray[m_cBackBuffers + 1].hKernelHandle,
REF_INTRINSIC,
&hr);
if (m_ppBackBuffers[m_cBackBuffers] == NULL)
{
// We'll clean up the kernel handle at the ned
// of the function
hr = E_OUTOFMEMORY;
break;
}
else
{
// Zero out the kernel-handle so that
// we don't clean it at exit. (Even in failure,
// the m_ppBackBuffers[m_cBackBuffers] object
// will free the kernel handle now
SurfInfoArray[m_cBackBuffers + 1].hKernelHandle = 0;
}
if (FAILED(hr))
{
m_ppBackBuffers[m_cBackBuffers]->DecrementUseCount();
m_ppBackBuffers[m_cBackBuffers] = NULL;
break;
}
}
if (m_cBackBuffers != cBackBuffers)
{
// Something went wrong, so clean up now.
// 2. Destroy Back Buffers, if any.
while (m_cBackBuffers > 0)
{
m_ppBackBuffers[--m_cBackBuffers]->DecrementUseCount();
}
delete [] m_ppBackBuffers;
m_ppBackBuffers = NULL;
}
else
{
const D3D8_DRIVERCAPS* pDriverCaps = Device()->GetCoreCaps();
m_dwFlipFlags = DDFLIP_WAIT;
if ((D3DPRESENT_INTERVAL_IMMEDIATE == m_PresentationData.FullScreen_PresentationInterval)
#ifdef WINNT
|| (D3D_REGFLAGS_FLIPNOVSYNC & m_dwFlags)
#endif
)
{
if (DDCAPS2_FLIPNOVSYNC & pDriverCaps->D3DCaps.Caps2)
{
m_dwFlipFlags |= DDFLIP_NOVSYNC;
}
}
else if (DDCAPS2_FLIPINTERVAL & pDriverCaps->D3DCaps.Caps2)
{
switch(m_PresentationData.FullScreen_PresentationInterval)
{
case D3DPRESENT_INTERVAL_DEFAULT:
case D3DPRESENT_INTERVAL_ONE:
m_dwFlipFlags |= DDFLIP_INTERVAL1;
break;
case D3DPRESENT_INTERVAL_TWO:
m_dwFlipFlags |= DDFLIP_INTERVAL2;
break;
case D3DPRESENT_INTERVAL_THREE:
m_dwFlipFlags |= DDFLIP_INTERVAL3;
break;
case D3DPRESENT_INTERVAL_FOUR:
m_dwFlipFlags |= DDFLIP_INTERVAL4;
break;
}
}
m_BltData.hWnd = m_PresentationData.hDeviceWindow;
m_BltData.dwFlags = DDBLT_ROP | DDBLT_WAIT;
m_ClientWidth = width;
m_ClientHeight = height;
}
}
else
{
hr = E_OUTOFMEMORY;
}
}
// Error handling cleanup
if (FAILED(hr))
{
// We may need to free surface handles that
// were not owned by any CDriverSurface that
// we failed to properly create
D3D8_DESTROYSURFACEDATA DestroyData;
ZeroMemory(&DestroyData, sizeof DestroyData);
DestroyData.hDD = Device()->GetHandle();
for (UINT i = 0; i < CreateSurfaceData.dwSCnt; i++)
{
if (CreateSurfaceData.pSList[i].hKernelHandle)
{
DestroyData.hSurface = CreateSurfaceData.pSList[i].hKernelHandle;
Device()->GetHalCallbacks()->DestroySurface(&DestroyData);
}
}
}
return hr;
} // CreateFullScreen
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::Destroy"
//=============================================================================
// CSwapChain::Destroy
//
// Created 11/16/1999 johnstep
//=============================================================================
VOID
CSwapChain::Destroy()
{
// Destroy surfaces in reverse create order.
if (m_pCursor)
{
delete m_pCursor;
m_pCursor = NULL;
}
// 2. Destroy Back Buffers
//
// If the previous mode was windowed, we should have exactly 1
// back buffer to destroy. Otherwise, there could be more than
// one, and plus we may need some sort of atomic destruction.
if (m_ppBackBuffers)
{
while (m_cBackBuffers > 0)
{
m_ppBackBuffers[--m_cBackBuffers]->DecrementUseCount();
}
delete [] m_ppBackBuffers;
m_ppBackBuffers = NULL;
}
// 1. Destroy Mirror Surface
if (m_pMirrorSurface)
{
m_pMirrorSurface->DecrementUseCount();
m_pMirrorSurface = NULL;
}
// 1. Destroy Primary Surface
if (m_pPrimarySurface)
{
if (this == Device()->SwapChain())
m_pPrimarySurface->DecrementUseCount();
m_pPrimarySurface = NULL;
m_hGDISurface = NULL;
}
m_presentnext = 0;
} // Destroy
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::GetBackBuffer"
//=============================================================================
// IDirect3DSwapChain8::GetBackBuffer (public)
//
// Created 11/16/1999 johnstep
//=============================================================================
STDMETHODIMP
CSwapChain::GetBackBuffer(
UINT iBackBuffer,
D3DBACKBUFFER_TYPE Type,
IDirect3DSurface8 **ppBackBuffer
)
{
API_ENTER(Device());
if (ppBackBuffer == NULL)
{
DPF_ERR("Invalid ppBackbuffer parameter passed to GetBackBuffer");
return D3DERR_INVALIDCALL;
}
// We can't just assert we have a valid back buffer array because a
// Reset may have failed, which puts the device in a disabled state
// until Reset is called again. Once we have a `disabled' flag, we
// can check that instead of m_ppBackBuffers.
if (m_ppBackBuffers == NULL)
{
DPF_ERR("GetBackBuffer failed due to Device being lost");
return D3DERR_INVALIDCALL;
}
// in case of windowed D3DSWAPEFFECT_FLIP, m_cBackBuffers
// == m_PresentationData.BackBufferCount + 1 as we allocate
// that extra buffer for user without its knowledge
if (iBackBuffer >= m_PresentationData.BackBufferCount)
{
DPF_ERR("Invalid iBackBuffer parameter passed to GetBackBuffer");
return D3DERR_INVALIDCALL;
}
*ppBackBuffer = BackBuffer(iBackBuffer);
DXGASSERT(*ppBackBuffer != NULL);
if (*ppBackBuffer)
{
(*ppBackBuffer)->AddRef();
return S_OK;
}
else
{
DPF(2, "Swapchain doesn't have a BackBuffer[%d]",iBackBuffer);
return D3DERR_NOTFOUND;
}
} // GetBackBuffer
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::Reset"
//=============================================================================
// IDirect3DSwapChain8::Reset (public)
//
// Resizes the device. If this results in a display mode change, then all
// existing surfaces will be lost.
//
// Arguments:
// width
// height
// pcBackBuffers (in/out) !!! Currently an (in) but will be fixed later.
// backBufferFormat
// fullscreen
// pOptionalParams
// Created 11/16/1999 johnstep
//=============================================================================
HRESULT
CSwapChain::Reset(
D3DPRESENT_PARAMETERS *pPresentationParameters
)
{
BOOL bDeviceLost = FALSE;
HRESULT hr;
// Validate First before changing state
switch (pPresentationParameters->SwapEffect)
{
case D3DSWAPEFFECT_DISCARD:
case D3DSWAPEFFECT_COPY:
case D3DSWAPEFFECT_COPY_VSYNC:
case D3DSWAPEFFECT_FLIP:
case D3DSWAPEFFECT_NO_PRESENT:
break;
default:
DPF_ERR("Invalid parameter for SwapEffect for D3DPRESENT_PARAMETERS. "
"Must be one of D3DSWAPEFFECTS_COPY, D3DSWAPEFFECTS_COPY_VSYNC, "
"D3DSWAPEFFECTS_DISCARD, or D3DSWAPEFFECTS_FLIP. CreateDevice/Reset Fails.");
return D3DERR_INVALIDCALL;
}
if (pPresentationParameters->BackBufferCount)
{
if ((D3DSWAPEFFECT_COPY == pPresentationParameters->SwapEffect ||
D3DSWAPEFFECT_COPY_VSYNC == pPresentationParameters->SwapEffect)
&& (pPresentationParameters->BackBufferCount > 1))
{
DPF_ERR("BackBufferCount must be 1 if SwapEffect is COPY/VSYNC. CreateDevice/Reset Fails.");
pPresentationParameters->BackBufferCount = 1;
return D3DERR_INVALIDCALL;
}
if (pPresentationParameters->BackBufferCount >
D3DPRESENT_BACK_BUFFERS_MAX)
{
DPF_ERR("BackBufferCount must be less "
"than D3DPRESENT_BACK_BUFFERS_MAX. CreateDevice/Reset Fails.");
pPresentationParameters->BackBufferCount =
D3DPRESENT_BACK_BUFFERS_MAX;
return D3DERR_INVALIDCALL;
}
}
else
{
pPresentationParameters->BackBufferCount = 1;
DPF(4, "BackBufferCount not specified, considered default 1 ");
}
if (D3DSWAPEFFECT_DISCARD != pPresentationParameters->SwapEffect)
{
if (pPresentationParameters->MultiSampleType != D3DMULTISAMPLE_NONE)
{
DPF_ERR("Multisampling requires D3DSWAPEFFECT_DISCARD. CreateDevice/Reset Fails.");
return D3DERR_INVALIDCALL;
}
}
// D3DSWAPEFFECT_NO_PRESENT is a hack that only works for windowed mode
if (D3DSWAPEFFECT_NO_PRESENT == pPresentationParameters->SwapEffect)
{
if (!pPresentationParameters->Windowed)
{
DPF_ERR("D3DSWAPEFFECT_NO_PRESENT only works when the device is windowed. CreateDevice/Reset Fails.");
return D3DERR_INVALIDCALL;
}
}
memcpy(&m_PresentationData,
pPresentationParameters,sizeof m_PresentationData);
// Remember the original swapeffect
m_UserSwapEffect = pPresentationParameters->SwapEffect;
// Convert discard to flip or copy based on stuff
if (D3DSWAPEFFECT_DISCARD == pPresentationParameters->SwapEffect)
{
if (pPresentationParameters->Windowed &&
pPresentationParameters->BackBufferCount == 1)
{
m_PresentationData.SwapEffect = D3DSWAPEFFECT_COPY;
}
else
{
m_PresentationData.SwapEffect = D3DSWAPEFFECT_FLIP;
}
}
if (NULL == m_PresentationData.hDeviceWindow)
{
m_PresentationData.hDeviceWindow= Device()->FocusWindow();
}
DXGASSERT( NULL != m_PresentationData.hDeviceWindow);
#ifdef WINNT
// On NT, SetCooperativeLevel will fail if another device has exclusive
// mode, so we cannot call it. On Win9X, it will not fail, but CreateSurface
// WILL fail if we don't first call it, so we need to special case this call.
if (m_UserSwapEffect != D3DSWAPEFFECT_NO_PRESENT)
{
#endif
hr = SetCooperativeLevel();
if (FAILED(hr))
{
DPF_ERR("SetCooperativeLevel returned failure. CreateDevice/Reset Failed");
return hr;
}
#ifdef WINNT
}
#endif
// See if the device is lost
if (D3D8IsDeviceLost(Device()->GetHandle()))
{
bDeviceLost = TRUE;
FetchDirectDrawData(Device()->GetDeviceData(),
Device()->GetInitFunction(),
Device()->Enum()->GetUnknown16(Device()->AdapterIndex()),
Device()->Enum()->GetHalOpList(Device()->AdapterIndex()),
Device()->Enum()->GetNumHalOps(Device()->AdapterIndex()));
}
// Map the unknown format to a real one. If they will take any format
// (i.e. the specified UNKNOWN), then we will try to give them the one
// that matches the display format.
if (m_PresentationData.Windowed)
{
// If we are windowed, we need to use the current display mode. We may be
// able to relax this for new drivers.
if (D3DFMT_UNKNOWN == m_PresentationData.BackBufferFormat)
{
m_PresentationData.BackBufferFormat = Device()->DisplayFormat();
}
if (CPixel::SuppressAlphaChannel(m_PresentationData.BackBufferFormat)
!= Device()->DisplayFormat())
{
DPF_ERR("Windowed BackBuffer Format must be compatible with Desktop Format. CreateDevice/Reset fails.");
return D3DERR_INVALIDCALL;
}
}
if (m_PresentationData.Windowed)
{
if ((m_PresentationData.BackBufferWidth < 1) ||
(m_PresentationData.BackBufferHeight < 1))
{
RECT rc;
if (GetClientRect(m_PresentationData.hDeviceWindow, &rc))
{
if (m_PresentationData.BackBufferWidth < 1)
m_PresentationData.BackBufferWidth = rc.right;
if (m_PresentationData.BackBufferHeight < 1)
m_PresentationData.BackBufferHeight = rc.bottom;
}
else
{
DPF_ERR("zero width and/or height and unable to get client. CreateDevice/Reset fails.");
return D3DERR_INVALIDCALL;
}
}
// We can handle color conversion from the back buffer if we use
// GDI BitBlt instead of DirectDraw Blt for presentation.
switch (m_PresentationData.BackBufferFormat)
{
case D3DFMT_X1R5G5B5:
case D3DFMT_A1R5G5B5:
case D3DFMT_R5G6B5:
case D3DFMT_X8R8G8B8:
case D3DFMT_A8R8G8B8:
break;
default:
DPF_ERR("Unsupported back buffer format specified.");
return D3DERR_INVALIDCALL;
}
// Does the device support offscreen RTs of this format in the current
// display mode?
if (FAILED(Device()->Enum()->CheckDeviceFormat(
Device()->AdapterIndex(),
Device()->GetDeviceType(),
Device()->DisplayFormat(),
D3DUSAGE_RENDERTARGET,
D3DRTYPE_SURFACE,
m_PresentationData.BackBufferFormat)))
{
DPF_ERR("This back buffer format is not supported for a windowed device. CreateDevice/Reset Fails");
DPF_ERR(" Use CheckDeviceType(Adapter, DeviceType, <Current Display Format>, <Desired BackBufferFormat>, TRUE /* Windowed */)");
return D3DERR_INVALIDCALL;
}
// For now, always destroy existing surfaces and recreate. Later, we
// may reuse the surfaces. We should also add an `initialized' flag,
// but for now will just arbitrarily use m_pPrimarySurface for this
// purpose.
if (this == Device()->SwapChain())
{
Device()->UpdateRenderTarget(NULL, NULL);
if (m_pPrimarySurface != NULL)
{
Device()->ResourceManager()->DiscardBytes(0);
static_cast<CD3DBase*>(Device())->Destroy();
Destroy();
}
if (Device()->GetZStencil() != NULL)
{
Device()->GetZStencil()->DecrementUseCount();
Device()->ResetZStencil();
}
if (D3D8DoVidmemSurfacesExist(Device()->GetHandle()))
{
// user must free any video memory surfaces before doing
// fullscreen Reset, otherwise we fail.
DPF_ERR("All user created D3DPOOL_DEFAULT surfaces must be freed"
" before Reset can succeed. Reset Fails.");
return D3DERR_DEVICELOST;
}
}
// If the device is lost, we should now restore it before creating
// the new swap chain.
if (bDeviceLost)
{
D3D8RestoreDevice(Device()->GetHandle());
}
hr = CreateWindowed(
Width(),
Height(),
BackBufferFormat(),
m_PresentationData.BackBufferCount,
m_PresentationData.MultiSampleType,
(D3DSWAPEFFECT_DISCARD == m_UserSwapEffect),
(pPresentationParameters->Flags & D3DPRESENTFLAG_LOCKABLE_BACKBUFFER)
);
}
else
{
D3DFORMAT FormatWithoutAlpha;
#ifdef WINNT
// Pick the best refresh rate
m_PresentationData.FullScreen_RefreshRateInHz = PickRefreshRate(
Width(),
Height(),
m_PresentationData.FullScreen_RefreshRateInHz,
m_PresentationData.BackBufferFormat);
#endif
// If they specified a mode, does the mode exist?
if (Width() != Device()->DisplayWidth()
|| Height() != Device()->DisplayHeight()
|| BackBufferFormat() != Device()->DisplayFormat()
|| ((m_PresentationData.FullScreen_RefreshRateInHz != 0) &&
(m_PresentationData.FullScreen_RefreshRateInHz !=
Device()->DisplayRate()))
)
{
D3DDISPLAYMODE* pModeTable = Device()->GetModeTable();
DWORD dwNumModes = Device()->GetNumModes();
DWORD i;
#if DBG
for (i = 0; i < dwNumModes; i++)
{
DPF(10,"Mode[%d] is %d x %d format=%08lx",
i,
pModeTable[i].Width,
pModeTable[i].Height,
pModeTable[i].Format);
}
#endif //DBG
FormatWithoutAlpha = CPixel::SuppressAlphaChannel(m_PresentationData.BackBufferFormat);
for (i = 0; i < dwNumModes; i++)
{
if ((pModeTable[i].Width == Width()) &&
(pModeTable[i].Height == Height()) &&
(pModeTable[i].Format == FormatWithoutAlpha))
{
// So far so good. Check refresh rate if they specified one
if ((m_PresentationData.FullScreen_RefreshRateInHz == 0) ||
(m_PresentationData.FullScreen_RefreshRateInHz ==
pModeTable[i].RefreshRate))
{
break;
}
}
}
if (i == dwNumModes)
{
// The specified mode is invalid
DPF_ERR("The specified mode is unsupported. CreateDevice/Reset Fails");
return D3DERR_INVALIDCALL;
}
// If the mode exists, does the device have caps in it?
if (FAILED(Device()->Enum()->CheckDeviceType(
Device()->AdapterIndex(),
Device()->GetDeviceType(),
FormatWithoutAlpha,
m_PresentationData.BackBufferFormat,
FALSE)))
{
DPF_ERR("Display Mode not supported by this device type. Use CheckDeviceType(X, X, <Desired fullscreen format>). CreateDevice/Reset Fails");
return D3DERR_INVALIDCALL;
}
// The mode is supported, so next we set the cooperative level to fullscreen
// Now do the mode change and update the driver caps
D3D8_SETMODEDATA SetModeData;
SetModeData.hDD = Device()->GetHandle();
SetModeData.dwWidth = Width();
SetModeData.dwHeight = Height();
SetModeData.Format = BackBufferFormat();
SetModeData.dwRefreshRate =
m_PresentationData.FullScreen_RefreshRateInHz;
SetModeData.bRestore = FALSE;
Device()->GetHalCallbacks()->SetMode(&SetModeData);
if (SetModeData.ddRVal != DD_OK)
{
DPF_ERR("Unable to set the new mode. CreateDevice/Reset Fails");
return SetModeData.ddRVal;
}
FetchDirectDrawData(Device()->GetDeviceData(), Device()->GetInitFunction(),
Device()->Enum()->GetUnknown16(Device()->AdapterIndex()),
Device()->Enum()->GetHalOpList(Device()->AdapterIndex()),
Device()->Enum()->GetNumHalOps(Device()->AdapterIndex()));
// We have to restore the device now, since out mode change above would
// have forced it to become lost.
bDeviceLost = TRUE; // need to restore right away
}
// For now, always destroy existing surfaces and recreate. Later, we
// may reuse the surfaces. We should also add an `initialized' flag,
// but for now will just arbitrarily use m_pPrimarySurface for this
// purpose.
Device()->UpdateRenderTarget(NULL, NULL);
if (m_pPrimarySurface != NULL)
{
Device()->ResourceManager()->DiscardBytes(0);
static_cast<CD3DBase*>(Device())->Destroy();
Destroy();
}
if (Device()->GetZStencil() != NULL)
{
Device()->GetZStencil()->DecrementUseCount();
Device()->ResetZStencil();
}
if (D3D8DoVidmemSurfacesExist(Device()->GetHandle()))
{
// user must free any video memory surfaces before doing
// fullscreen Reset, otherwise we fail.
DPF_ERR("All user created D3DPOOL_DEFAULT surfaces must be freed"
" before Reset can succeed. Reset Fails");
return D3DERR_DEVICELOST;
}
if (bDeviceLost)
{
D3D8RestoreDevice(Device()->GetHandle());
}
hr = CreateFullscreen(
m_PresentationData.BackBufferWidth,
m_PresentationData.BackBufferHeight,
m_PresentationData.BackBufferFormat,
m_PresentationData.BackBufferCount,
m_PresentationData.FullScreen_PresentationInterval,
m_PresentationData.MultiSampleType,
(D3DSWAPEFFECT_DISCARD == m_UserSwapEffect),
(pPresentationParameters->Flags & D3DPRESENTFLAG_LOCKABLE_BACKBUFFER)
);
#ifdef WINNT
if (SUCCEEDED(hr))
{
MakeFullscreen();
}
#endif //WINNT
// Restore the gamma ramp if it was previously set
if (m_GammaSet && SUCCEEDED(hr))
{
SetGammaRamp(0, &m_DesiredGammaRamp);
}
}
if (SUCCEEDED(hr))
{
m_pCursor = new CCursor(Device());
m_bClientChanged = TRUE;
m_pSrcRect = m_pDstRect = NULL;
}
return hr;
} // Reset
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::ClipIntervals"
//=============================================================================
// ClipIntervals
//
// calculate [low1 high1] and [low2 high2] after considering [low high]
//
// - [low1 high1] will be the interval corresponding to the width/height of
// target's size
//
// - [low2 high2] will be the interval corresponding to the width/height of
// the source's size
//
// - [low high] will be the interval corresponding of the width/height of
// the target clip
//
// The intention of this function is to clip the source for certain
// stretch scenarios where the target is clipped.
//
// Created 05/17/2000 kanqiu
//=============================================================================
void ClipIntervals(long & low1, long & high1,
long & low2, long & high2,
const long low, const long high)
{
DXGASSERT(low1 < high1);
DXGASSERT(low2 < high2);
DXGASSERT(low < high);
// shrink the target interval to lie within our Destination Clip [low high]
if (low > low1)
{
low1 = low;
}
if (high < high1)
{
high1 = high;
}
// if the destination interval is the same size as the destination
// clip, then we don't need to do anything
long length1 = high1 - low1;
long length = high - low;
// see if clamp is needed for low2 and high2 proportionally
if (length1 != length)
{
// find the length of our source interval
long length2 = high2 - low2;
// if the destination clip's low is outside our
// target's low
if (low < low1)
{
// Adjust the source low proportionally
low2 += (low1 - low) * length2 / length;
}
// if the destination clip's high is outside our
// target's high
if (high > high1)
{
// Adjust the source high proportionally
high2 -= (high - high1) * length2 / length;
}
/*
* Check for zero-sized dimensions and bump if necessary
*/
DXGASSERT(high2 >= low2);
if (low2 == high2)
{
if (low1 - low >= high - high1)
{
low2--;
}
else
{
high2++;
}
}
}
} // ClipIntervals
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::ClipRects"
//=============================================================================
// ClipRects
//
// calculate pSrc and pDst after considering pSrcRect and pDstRect
//
// Created 05/17/2000 kanqiu
//=============================================================================
inline HRESULT ClipRects(RECT * pSrc, RECT * pDst,
RECT * pSrcRect, const RECT * pDstRect)
{
RECT SrcRect;
if (pDstRect)
{
if (pDstRect->top >= pDst->bottom ||
pDstRect->bottom <= pDst->top ||
pDstRect->left >= pDst->right ||
pDstRect->right <= pDst->left ||
pDstRect->top >= pDstRect->bottom ||
pDstRect->left >= pDstRect->right
)
{
// in case of insane RECT, fail it
DPF_ERR("Unable to present with invalid destionation RECT");
return D3DERR_INVALIDCALL;
}
if (pSrcRect)
{
SrcRect = *pSrcRect;
pSrcRect = &SrcRect; //make a local copy and then update
ClipIntervals(pDst->top,pDst->bottom,pSrcRect->top,pSrcRect->bottom,
pDstRect->top,pDstRect->bottom);
ClipIntervals(pDst->left,pDst->right,pSrcRect->left,pSrcRect->right,
pDstRect->left,pDstRect->right);
}
else
{
ClipIntervals(pDst->top,pDst->bottom,pSrc->top,pSrc->bottom,
pDstRect->top,pDstRect->bottom);
ClipIntervals(pDst->left,pDst->right,pSrc->left,pSrc->right,
pDstRect->left,pDstRect->right);
}
}
// this pSrcRect is either what the user passed in (if there is no pDstRect)
// or it now points to "SrcRect" temp which contains the clipped version
// of what the user passed it.
if (pSrcRect)
{
if (pSrcRect->top >= pSrc->bottom ||
pSrcRect->bottom <= pSrc->top ||
pSrcRect->left >= pSrc->right ||
pSrcRect->right <= pSrc->left ||
pSrcRect->top >= pSrcRect->bottom ||
pSrcRect->left >= pSrcRect->right
)
{
// in case of insane RECT, fail it
DPF_ERR("Unable to present with invalid source RECT");
return D3DERR_INVALIDCALL;
}
ClipIntervals(pSrc->top,pSrc->bottom,pDst->top,pDst->bottom,
pSrcRect->top,pSrcRect->bottom);
ClipIntervals(pSrc->left,pSrc->right,pDst->left,pDst->right,
pSrcRect->left,pSrcRect->right);
}
return S_OK;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::UpdateFrameRate"
/*
* updateFrameRate
*/
void
CSwapChain::UpdateFrameRate( void )
{
/*
* work out the frame rate if required...
*/
if( 0xffffffff == m_dwFlipTime )
{
m_dwFlipTime = GetTickCount();
}
m_dwFlipCnt++;
if( m_dwFlipCnt >= 120 )
{
DWORD time2;
DWORD fps;
char buff[256];
time2 = GetTickCount() - m_dwFlipTime;
// Only do this at most every two seconds
if (time2 >= 2000)
{
fps = (m_dwFlipCnt*10000)/time2;
wsprintf(buff, "Adapter %d FPS = %ld.%01ld\r\n",
Device()->AdapterIndex(), fps/10, fps % 10 );
OutputDebugString(buff);
m_dwFlipTime = GetTickCount();
m_dwFlipCnt = 0;
}
}
} /* updateFrameRate */
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::DebugDiscardBackBuffer"
#ifdef DEBUG
void CSwapChain::DebugDiscardBackBuffer(HANDLE SurfaceToClear) const
{
// Disregard SW or Ref
if (Device()->GetDeviceType() == D3DDEVTYPE_REF ||
Device()->GetDeviceType() == D3DDEVTYPE_SW)
{
return;
}
if (m_UserSwapEffect != D3DSWAPEFFECT_DISCARD)
{
return;
}
D3D8_BLTDATA ColorFill;
ZeroMemory(&ColorFill, (sizeof ColorFill));
ColorFill.hDD = Device()->GetHandle();
ColorFill.hDestSurface = SurfaceToClear;
ColorFill.dwFlags = DDBLT_COLORFILL | DDBLT_WAIT;
ColorFill.rDest.right = Width();
ColorFill.rDest.bottom = Height();
// Switch between magenta and the inverse
static BOOL bMagenta = FALSE;
DWORD Color;
switch(Device()->DisplayFormat())
{
case D3DFMT_X8R8G8B8:
case D3DFMT_R8G8B8:
if (bMagenta)
Color = 0x00FF007F;
else
Color = 0x0000FF00;
break;
case D3DFMT_X1R5G5B5:
if (bMagenta)
Color = 0x7C0F;
else
Color = 0x03E0;
break;
case D3DFMT_R5G6B5:
if (bMagenta)
Color = 0xF80F;
else
Color = 0x07E0;
break;
}
if (bMagenta)
bMagenta = FALSE;
else
bMagenta = TRUE;
ColorFill.bltFX.dwFillColor = Color;
// In debug we want to clear the back-buffer
// if we're in discard mode
Device()->GetHalCallbacks()->Blt(&ColorFill);
return;
} // DebugDiscardBackBuffer
#endif // DEBUG
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::Present"
//=============================================================================
// IDirect3DSwapChain8::Present (public)
//
// Moves data from back-buffer to the primary
//
// Created 11/16/1999 johnstep
//=============================================================================
STDMETHODIMP
CSwapChain::Present(
CONST RECT *pSrcRect,
CONST RECT *pDestRect,
HWND hWndDestOverride,
CONST RGNDATA *pDirtyRegion
)
{
API_ENTER(Device());
HRESULT hr = E_FAIL;
// First, fail if the device is lost
if (D3D8IsDeviceLost(Device()->GetHandle()))
{
return D3DERR_DEVICELOST;
}
if (!m_ppBackBuffers)
{
return D3DERR_DEVICELOST;
}
if (D3DSWAPEFFECT_FLIP == m_PresentationData.SwapEffect)
{
if (NULL != pSrcRect || NULL != pDestRect || NULL != pDirtyRegion)
{
DPF_ERR("pSrcRect pDestRect pDirtyRegion must be NULL with "
"D3DSWAPEFFECT_FLIP. Present Fails.");
return D3DERR_INVALIDCALL;
}
}
if (NULL != pDirtyRegion)
{
DPF_ERR("Present with non-null pDirtyRegion is not supported");
return D3DERR_INVALIDCALL;
}
for (UINT i = 0; i < m_cBackBuffers; i++)
{
if (m_ppBackBuffers[i]->IsLocked())
{
DPF_ERR("A BackBuffer in this swap chain is Locked. Present failed.");
return D3DERR_INVALIDCALL;
}
}
// Check if we need to act against HW that queues too much
if (PresentUseBlt())
{
if (Device()->GetDeviceData()->DriverData.D3DCaps.MaxStreams == 0)
{
// Only pre-DX8 level drivers are suspected...
if (0 == (Device()->GetDeviceData()->DriverData.KnownDriverFlags & KNOWN_NOTAWINDOWEDBLTQUEUER))
{
// We don't want to treat a vis-region change as a failure to
// prevent the thunk layer from calling Reset. Reset
// confuses the clip-list caching that is done for Present.
//
// Also we want don't want to spew any errors here.
DPF_MUTE();
D3DLOCKED_RECT LockRect;
// all we need is a Lock sent down to driver so it would flush the queue
// therefore 1x1 rect is enough, larger area of lock would cause sprites to flick
// and therefore also slow down the system.
RECT DummyRect={0,0,1,1};
hr = m_pPrimarySurface->InternalLockRect(&LockRect, &DummyRect, DDLOCK_FAILONVISRGNCHANGED);
if (SUCCEEDED(hr))
{
m_pPrimarySurface->InternalUnlockRect();
}
else
{
hr = S_OK;
}
DPF_UNMUTE();
}
}
}
#ifdef WINNT
// If ~ 50 seconds have passed (assuming a 10Hz flip rate)
// and this is a primary surface, then make a magic call to
// disable screen savers.
// This isn't needed on 9x since we make a SPI call on that OS
// to disable screen savers.
if (0 == (Device()->BehaviorFlags() & 0x10000000)) //SCREENSAVER magic number
{
if (!m_PresentationData.Windowed)
{
static DWORD dwMagicTime = 0;
dwMagicTime++;
if (dwMagicTime > (50*10) )
{
DWORD dw=60*15;
dwMagicTime = 0;
SystemParametersInfo(SPI_GETSCREENSAVETIMEOUT,0,&dw,0);
SystemParametersInfo(SPI_SETSCREENSAVETIMEOUT,dw,0,0);
}
}
}
#endif
// Flush any pending commands before we send the Flip/Blt
static_cast<CD3DBase*>(Device())->FlushStatesNoThrow();
if ( FALSE == PresentUseBlt())
{
// We are fullscreen, so turn this into a flip
DXGASSERT(0==m_presentnext);
hr = FlipToSurface(BackBuffer(0)->KernelHandle());
}
else
{
if (m_PresentationData.Windowed)
{
RECT DestRect;
//
// Choose the presentation window. Override, or device window?
//
if (hWndDestOverride)
m_BltData.hWnd = hWndDestOverride;
else
m_BltData.hWnd = m_PresentationData.hDeviceWindow;
//The left and top members are zero. The right and bottom
//members contain the width and height of the window.
if (!GetClientRect(m_BltData.hWnd, &DestRect))
{
// in case of this unlikely event, fail it
DPF_ERR("Unable to get client during presentation");
return D3DERR_INVALIDCALL;
}
if (((UINT)DestRect.bottom != m_ClientHeight)
|| ((UINT)DestRect.right != m_ClientWidth)
)
{
m_bClientChanged = TRUE;
m_ClientHeight = (UINT)DestRect.bottom;
m_ClientWidth = (UINT)DestRect.right;
}
}
if (D3DSWAPEFFECT_FLIP != m_PresentationData.SwapEffect)
{
if (pSrcRect)
{
if (m_pSrcRect)
{
if (memcmp(pSrcRect,m_pSrcRect,sizeof RECT))
{
m_bClientChanged = TRUE;
m_SrcRect = *pSrcRect;
}
}
else
{
m_bClientChanged = TRUE;
m_pSrcRect = &m_SrcRect;
m_SrcRect = *pSrcRect;
}
}
else if (m_pSrcRect)
{
m_bClientChanged = TRUE;
m_pSrcRect = NULL;
}
if (pDestRect)
{
if (m_pDstRect)
{
if (memcmp(pDestRect,m_pDstRect,sizeof RECT))
{
m_bClientChanged = TRUE;
m_DstRect = *pDestRect;
}
}
else
{
m_bClientChanged = TRUE;
m_pDstRect = &m_DstRect;
m_DstRect = *pDestRect;
}
}
else if (m_pDstRect)
{
m_bClientChanged = TRUE;
m_pDstRect = NULL;
}
}
if (m_bClientChanged)
{
m_bClientChanged = FALSE;
m_BltData.rSrc.left = m_BltData.rSrc.top = 0;
m_BltData.rSrc.right = Width();
m_BltData.rSrc.bottom = Height();
m_BltData.rDest.left = m_BltData.rDest.top = 0;
m_BltData.rDest.right = m_ClientWidth;
m_BltData.rDest.bottom = m_ClientHeight;
hr = ClipRects((RECT*)&m_BltData.rSrc, (RECT*)&m_BltData.rDest,
m_pSrcRect, m_pDstRect);
if (FAILED(hr))
{
return hr;
}
}
m_BltData.hSrcSurface =
m_ppBackBuffers[m_presentnext]->KernelHandle();
// Lock the software driver created buffer
// and unlock it immediately
if ((D3DDEVTYPE_HAL != Device()->GetDeviceType()) &&
(D3DMULTISAMPLE_NONE != m_PresentationData.MultiSampleType)
)
{
D3D8_LOCKDATA lockData;
ZeroMemory(&lockData, sizeof lockData);
lockData.hDD = Device()->GetHandle();
lockData.hSurface = m_BltData.hSrcSurface;
lockData.dwFlags = DDLOCK_READONLY;
hr = Device()->GetHalCallbacks()->Lock(&lockData);
if (SUCCEEDED(hr))
{
D3D8_UNLOCKDATA unlockData;
ZeroMemory(&unlockData, sizeof unlockData);
unlockData.hDD = Device()->GetHandle();
unlockData.hSurface = m_BltData.hSrcSurface;
hr = Device()->GetHalCallbacks()->Unlock(&unlockData);
if (FAILED(hr))
{
DPF_ERR("Driver failed to unlock MultiSample backbuffer. Present fails.");
return hr;
}
}
else
{
DPF_ERR("Driver failed to lock MultiSample backbuffer. Present Fails.");
return hr;
}
}
if (DDHAL_DRIVER_NOTHANDLED
== Device()->GetHalCallbacks()->Blt(&m_BltData))
{
hr = E_FAIL;
}
else
{
hr = m_BltData.ddRVal;
// Handle deferred DP2 errors specially
if (hr == D3DERR_DEFERRED_DP2ERROR)
{
// We only want to make this "error" visible
// if we have been created with the right flag
if (Device()->BehaviorFlags() & D3DCREATE_SHOW_DP2ERROR)
{
DPF_ERR("A prior call to DrawPrim2 has failed; returning error from Present.");
}
else
{
// Quietly just mask this error; this is ok; because
// we known that the Blt succeeded
hr = S_OK;
}
}
}
if (FAILED(hr))
{
DPF_ERR("BitBlt or StretchBlt failed in Present");
return hr;
}
// Clear the backbuffer if the user has specified
// discard semantics
DebugDiscardBackBuffer(m_BltData.hSrcSurface);
if (m_pMirrorSurface)
{
hr = FlipToSurface(m_pMirrorSurface->KernelHandle());
// need to reset it
m_BltData.hDestSurface = m_pMirrorSurface->KernelHandle();
if (FAILED(hr))
{
DPF_ERR("Driver failed Flip. Present Fails.");
return hr;
}
}
if (m_cBackBuffers > 1)
{
if (m_PresentationData.SwapEffect == D3DSWAPEFFECT_FLIP)
{
HANDLE hRenderTargetHandle =
Device()->RenderTarget()->KernelHandle();
BOOL bNeedSetRendertarget = FALSE;
HANDLE hSurfTarg = BackBuffer(0)->KernelHandle();
DXGASSERT(0 == m_presentnext);
for (int i = m_cBackBuffers - 1; i >= 0; i--)
{
if (hSurfTarg == hRenderTargetHandle)
bNeedSetRendertarget = TRUE;
// This swap handles function will
// return the value that were currently
// in the surface; which we use to
// pass to the next surface.
m_ppBackBuffers[i]->SwapKernelHandles(&hSurfTarg);
}
if (bNeedSetRendertarget)
(static_cast<CD3DBase*>(Device()))->SetRenderTargetI(
Device()->RenderTarget(),
Device()->ZBuffer());
}
else
if (++m_presentnext >= m_cBackBuffers)
{
m_presentnext = 0;
}
}
}
if ( D3D_REGFLAGS_SHOWFRAMERATE & m_dwFlags)
{
UpdateFrameRate();
}
return hr;
} // Present
HRESULT
CSwapChain::FlipToSurface(HANDLE hTargetSurface)
{
HRESULT hr;
D3D8_FLIPDATA FlipData;
HANDLE hSurfTarg;
FlipData.hDD = Device()->GetHandle();
FlipData.hSurfCurr = PrimarySurface()->KernelHandle();
FlipData.hSurfTarg = hTargetSurface;
FlipData.hSurfCurrLeft = NULL;
FlipData.hSurfTargLeft = NULL;
FlipData.dwFlags = m_dwFlipFlags;
m_pCursor->Flip();
hr = m_pCursor->Show(FlipData.hSurfTarg);
Device()->GetHalCallbacks()->Flip(&FlipData);
m_pCursor->Flip();
hr = m_pCursor->Hide(FlipData.hSurfCurr);
m_pCursor->Flip();
hr = FlipData.ddRVal;
// Handle deferred DP2 errors specially
if (hr == D3DERR_DEFERRED_DP2ERROR)
{
// We only want to make this "error" visible
// if we have been created with the right flag
if (Device()->BehaviorFlags() & D3DCREATE_SHOW_DP2ERROR)
{
DPF_ERR("A prior call to DrawPrim2 has failed; returning error from Present.");
}
else
{
// Quietly just mask this error; this is ok; because
// we known that the Flip succeeded
hr = S_OK;
}
}
// In debug, we may need to clear the data from
// our new back-buffer if the user specified
// SWAPEFFECT_DISCARD
DebugDiscardBackBuffer(FlipData.hSurfCurr);
if (m_pMirrorSurface)
{
hSurfTarg = PrimarySurface()->KernelHandle();
m_pMirrorSurface->SwapKernelHandles(&hSurfTarg);
PrimarySurface()->SwapKernelHandles(&hSurfTarg);
}
else
{
HANDLE hRenderTargetHandle;
CBaseSurface* pRenderTarget = Device()->RenderTarget();
if (pRenderTarget)
hRenderTargetHandle = pRenderTarget->KernelHandle();
else
hRenderTargetHandle = 0;
while (hTargetSurface != PrimarySurface()->KernelHandle())
{
hSurfTarg = PrimarySurface()->KernelHandle();
for (int i = m_cBackBuffers-1; i>=0; i--)
{
BackBuffer(i)->SwapKernelHandles(&hSurfTarg);
}
PrimarySurface()->SwapKernelHandles(&hSurfTarg);
}
if (hRenderTargetHandle)
{
BOOL bNeedSetRendertarget;
if (PrimarySurface()->KernelHandle() == hRenderTargetHandle)
{
bNeedSetRendertarget = TRUE;
}
else
{
bNeedSetRendertarget = FALSE;
for (int i = m_cBackBuffers-1; i>=0; i--)
{
if (BackBuffer(i)->KernelHandle() == hRenderTargetHandle)
{
bNeedSetRendertarget = TRUE;
break;
}
}
}
if (bNeedSetRendertarget)
{
(static_cast<CD3DBase*>(Device()))->SetRenderTargetI(
Device()->RenderTarget(),
Device()->ZBuffer());
}
}
}
return hr;
}
HRESULT
CSwapChain::FlipToGDISurface(void)
{
D3D8_FLIPTOGDISURFACEDATA FlipToGDISurfaceData;
FlipToGDISurfaceData.ddRVal = DD_OK;
FlipToGDISurfaceData.dwToGDI = TRUE;
FlipToGDISurfaceData.hDD = Device()->GetHandle();
Device()->GetHalCallbacks()->FlipToGDISurface(&FlipToGDISurfaceData);
if (NULL != m_hGDISurface && PrimarySurface() &&
PrimarySurface()->KernelHandle() != m_hGDISurface)
{
return FlipToSurface(m_hGDISurface);
}
return FlipToGDISurfaceData.ddRVal;
} // FlipToGDISurface
void
CSwapChain::SetGammaRamp(
DWORD dwFlags, // Calibrated or not.
CONST D3DGAMMARAMP *pRamp)
{
D3DGAMMARAMP TempRamp;
D3DGAMMARAMP * pRampToPassToHardware;
m_DesiredGammaRamp = *pRamp;
// Assume this for now. Calibration may use a temporary.
pRampToPassToHardware = &m_DesiredGammaRamp;
// If they want to calibrate the gamma, we will do that now. We will
// copy this to a different buffer so that we don't mess up the one
// passed in to us.
if (dwFlags & D3DSGR_CALIBRATE)
{
TempRamp = *pRamp;
Device()->Enum()->LoadAndCallGammaCalibrator(
&TempRamp,
(UCHAR*) Device()->GetDeviceData()->DriverName);
pRampToPassToHardware = &TempRamp;
}
DXGASSERT(pRampToPassToHardware);
DXGASSERT(Device()->GetDeviceData()->hDD);
DXGASSERT(Device()->GetDeviceData()->hDC);
D3D8SetGammaRamp(
Device()->GetDeviceData()->hDD,
Device()->GetDeviceData()->hDC,
pRampToPassToHardware);
if (pRamp != NULL)
{
m_GammaSet = TRUE;
}
else
{
m_GammaSet = FALSE;
}
}
void
CSwapChain::GetGammaRamp(
D3DGAMMARAMP *pRamp)
{
*pRamp = m_DesiredGammaRamp;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CSwapChain::SetCooperativeLevel"
/*
* DD_SetCooperativeLevel
*/
HRESULT
CSwapChain::SetCooperativeLevel()
{
#if _WIN32_WINNT >= 0x0501
{
//Turn off ghosting for any exclusive-mode app
//(Whistler onwards only)
typedef void (WINAPI *PFN_NOGHOST)( void );
HINSTANCE hInst = NULL;
hInst = LoadLibrary( "user32.dll" );
if( hInst )
{
PFN_NOGHOST pfnNoGhost = NULL;
pfnNoGhost = (PFN_NOGHOST)GetProcAddress( (HMODULE)hInst, "DisableProcessWindowsGhosting" );
if( pfnNoGhost )
{
pfnNoGhost();
}
FreeLibrary( hInst );
}
}
#endif // _WIN32_WINNT >= 0x0501
HRESULT ddrval;
#ifndef WINNT
ddrval = D3D8SetCooperativeLevel(Device()->GetHandle(),
m_PresentationData.hDeviceWindow,
m_PresentationData.Windowed ? DDSCL_NORMAL :
(DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_SETDEVICEWINDOW));
if (FAILED(ddrval))
return ddrval;
#else
BOOL bThisDeviceOwnsExclusive;
BOOL bExclusiveExists;
bExclusiveExists =
Device()->Enum()->CheckExclusiveMode(Device(),
&bThisDeviceOwnsExclusive,
!m_PresentationData.Windowed);
/*
* exclusive mode?
*/
if (m_PresentationData.Windowed)
/*
* no, must be regular
*/
{
DoneExclusiveMode(FALSE);
ddrval = SetAppHWnd();
}
if (bExclusiveExists && !bThisDeviceOwnsExclusive)
{
DPF_ERR("Exclusive Mode has been taken by other app or "
"other device on the same adapter. "
"SetCooperativeLevel returns D3DERR_DEVICELOST.");
return D3DERR_DEVICELOST;
}
if (!m_PresentationData.Windowed)
{
if (GetWindowLong(Device()->FocusWindow(), GWL_STYLE) & WS_CHILD)
{
DPF_ERR( "Focus Window must be a top level window. CreateDevice fails." );
return D3DERR_INVALIDCALL;
}
ddrval = SetAppHWnd();
if (S_OK == ddrval)
{
StartExclusiveMode(FALSE);
SetForegroundWindow(m_PresentationData.hDeviceWindow);
}
}
#endif
return ddrval;
} /* SetCooperativeLevel */
#ifdef WINNT
/*
* PickRefreshRate
*
* On NT, we want to pick a high reffresh rate, but we don't want to pick one
* too high. In theory, mode pruning would be 100% safe and we can always pick
* a high one, but we don't trust it 100%.
*/
DWORD
CSwapChain::PickRefreshRate(
DWORD Width,
DWORD Height,
DWORD RefreshRate,
D3DFORMAT Format)
{
D3DFORMAT FormatWithoutAlpha;
D3DDISPLAYMODE* pModeTable = Device()->GetModeTable();
DWORD dwNumModes = Device()->GetNumModes();
DWORD i;
FormatWithoutAlpha = CPixel::SuppressAlphaChannel(Format);
// We will always use the refresh rate from the registry if it's specified.
if (m_dwForceRefreshRate > 0)
{
for (i = 0; i < dwNumModes; i++)
{
if ((pModeTable[i].Width == Width) &&
(pModeTable[i].Height == Height) &&
(pModeTable[i].Format == FormatWithoutAlpha) &&
(m_dwForceRefreshRate == pModeTable[i].RefreshRate))
{
return m_dwForceRefreshRate;
}
}
}
// If the app specified the refresh rate, then we'll use it; otherwise, we
// will pick one ourselves.
if (RefreshRate == 0)
{
// If the mode requires no more bandwidth than the desktop mode from which
// the app was launched, we will go ahead and try that mode.
DEVMODE dm;
ZeroMemory(&dm, sizeof dm);
dm.dmSize = sizeof dm;
EnumDisplaySettings(Device()->GetDeviceData()->DriverName,
ENUM_REGISTRY_SETTINGS, &dm);
if ((Width <= dm.dmPelsWidth) &&
(Height <= dm.dmPelsHeight))
{
// Now check to see if it's supported
for (i = 0; i < dwNumModes; i++)
{
if ((pModeTable[i].Width == Width) &&
(pModeTable[i].Height == Height) &&
(pModeTable[i].Format == FormatWithoutAlpha) &&
(dm.dmDisplayFrequency == pModeTable[i].RefreshRate))
{
RefreshRate = dm.dmDisplayFrequency;
break;
}
}
}
// If we still don't have a refresh rate, try 75hz
if (RefreshRate == 0)
{
for (i = 0; i < dwNumModes; i++)
{
if ((pModeTable[i].Width == Width) &&
(pModeTable[i].Height == Height) &&
(pModeTable[i].Format == FormatWithoutAlpha) &&
(75 == pModeTable[i].RefreshRate))
{
RefreshRate = 75;
break;
}
}
}
// If we still don't have a refresh rate, use 60hz
if (RefreshRate == 0)
{
for (i = 0; i < dwNumModes; i++)
{
if ((pModeTable[i].Width == Width) &&
(pModeTable[i].Height == Height) &&
(pModeTable[i].Format == FormatWithoutAlpha) &&
(pModeTable[i].RefreshRate == 60))
{
RefreshRate = pModeTable[i].RefreshRate;
break;
}
}
}
}
return RefreshRate;
}
#endif
// End of file : swapchain.cpp
Reference in a new issue Copy permalink