Context Navigation

OgreD3D9RenderWindow.cpp @ 692

Revision 692, 27.2 KB checked in by mattausch, 19 years ago (diff)
adding ogre 1.2 and dependencies

Rev	Line
[692]	1	/*
	2	-----------------------------------------------------------------------------
	3	This source file is part of OGRE
	4	(Object-oriented Graphics Rendering Engine)
	5	For the latest info, see http://www.ogre3d.org/
	6
	7	Copyright (c) 2000-2005 The OGRE Team
	8	Also see acknowledgements in Readme.html
	9
	10	This program is free software; you can redistribute it and/or modify it under
	11	the terms of the GNU Lesser General Public License as published by the Free Software
	12	Foundation; either version 2 of the License, or (at your option) any later
	13	version.
	14
	15	This program is distributed in the hope that it will be useful, but WITHOUT
	16	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	17	FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
	18
	19	You should have received a copy of the GNU Lesser General Public License along with
	20	this program; if not, write to the Free Software Foundation, Inc., 59 Temple
	21	Place - Suite 330, Boston, MA 02111-1307, USA, or go to
	22	http://www.gnu.org/copyleft/lesser.txt.
	23	-----------------------------------------------------------------------------
	24	*/
	25	#include "OgreD3D9RenderWindow.h"
	26	#include "OgreLogManager.h"
	27	#include "OgreViewport.h"
	28	#include "OgreException.h"
	29	#include "OgreD3D9RenderSystem.h"
	30	#include "OgreRenderSystem.h"
	31	#include "OgreBitwise.h"
	32	#include "OgreImageCodec.h"
	33	#include "OgreStringConverter.h"
	34
	35	#include "OgreNoMemoryMacros.h"
	36	#include <d3d9.h>
	37	#include "OgreMemoryMacros.h"
	38	#include "OgreRoot.h"
	39
	40	namespace Ogre
	41	{
	42	// Window procedure callback
	43	// This is a static member, so applies to all windows but we store the
	44	// D3D9RenderWindow instance in the window data GetWindowLog/SetWindowLog
	45	LRESULT D3D9RenderWindow::WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
	46	{
	47	if (uMsg == WM_CREATE)
	48	{
	49	// copy D3D9RenderWindow* from createwindow param to userdata slot
	50	SetWindowLong(hWnd, GWL_USERDATA,
	51	(LONG)(((LPCREATESTRUCT)lParam)->lpCreateParams));
	52	return 0;
	53	}
	54
	55	D3D9RenderWindow* win =
	56	(D3D9RenderWindow*)GetWindowLong(hWnd, GWL_USERDATA);
	57
	58	if (!win)
	59	return DefWindowProc(hWnd, uMsg, wParam, lParam);
	60
	61	switch( uMsg )
	62	{
	63	case WM_ACTIVATE:
	64	win->mActive = (LOWORD(wParam) != WA_INACTIVE);
	65	break;
	66
	67	case WM_ENTERSIZEMOVE:
	68	win->mSizing = true;
	69	break;
	70
	71	case WM_EXITSIZEMOVE:
	72	win->windowMovedOrResized();
	73	win->mSizing = false;
	74	break;
	75
	76	case WM_MOVE:
	77	case WM_SIZE:
	78	if (!win->mSizing)
	79	win->windowMovedOrResized();
	80	break;
	81
	82	case WM_GETMINMAXINFO:
	83	// Prevent the window from going smaller than some minimu size
	84	((MINMAXINFO*)lParam)->ptMinTrackSize.x = 100;
	85	((MINMAXINFO*)lParam)->ptMinTrackSize.y = 100;
	86	break;
	87
	88	case WM_CLOSE:
	89	win->destroy(); // cleanup and call DestroyWindow
	90	win->mClosed = true;
	91	return 0;
	92	}
	93
	94	return DefWindowProc( hWnd, uMsg, wParam, lParam );
	95	}
	96
	97	D3D9RenderWindow::D3D9RenderWindow(HINSTANCE instance, D3D9Driver *driver, LPDIRECT3DDEVICE9 deviceIfSwapChain):
	98	mInstance(instance),
	99	mDriver(driver)
	100	{
	101	mIsFullScreen = false;
	102	mIsSwapChain = (deviceIfSwapChain != NULL);
	103	mIsExternal = false;
	104	mHWnd = 0;
	105	mActive = false;
	106	mSizing = false;
	107	mClosed = false;
	108	}
	109
	110	D3D9RenderWindow::~D3D9RenderWindow()
	111	{
	112	destroyD3DResources();
	113	}
	114
	115	bool D3D9RenderWindow::_checkMultiSampleQuality(D3DMULTISAMPLE_TYPE type, DWORD *outQuality, D3DFORMAT format, UINT adapterNum, D3DDEVTYPE deviceType, BOOL fullScreen)
	116	{
	117	LPDIRECT3D9 pD3D = mDriver->getD3D();
	118
	119	if (SUCCEEDED(pD3D->CheckDeviceMultiSampleType(
	120	adapterNum,
	121	deviceType, format,
	122	fullScreen, type, outQuality)))
	123	return true;
	124	else
	125	return false;
	126	}
	127
	128	void D3D9RenderWindow::create(const String& name, unsigned int width, unsigned int height,
	129	bool fullScreen, const NameValuePairList *miscParams)
	130	{
	131	HINSTANCE hInst = mInstance;
	132	D3D9Driver* driver = mDriver;
	133
	134	HWND parentHWnd = 0;
	135	HWND externalHandle = 0;
	136	mFSAAType = D3DMULTISAMPLE_NONE;
	137	mFSAAQuality = 0;
	138	mVSync = false;
	139	unsigned int displayFrequency = 0;
	140	String title = name;
	141	unsigned int colourDepth = 32;
	142	int left = -1; // Defaults to screen center
	143	int top = -1; // Defaults to screen center
	144	bool depthBuffer = true;
	145	String border = "";
	146	bool outerSize = false;
	147	mUseNVPerfHUD = false;
	148
	149	if(miscParams)
	150	{
	151	// Get variable-length params
	152	NameValuePairList::const_iterator opt;
	153	// left (x)
	154	opt = miscParams->find("left");
	155	if(opt != miscParams->end())
	156	left = StringConverter::parseInt(opt->second);
	157	// top (y)
	158	opt = miscParams->find("top");
	159	if(opt != miscParams->end())
	160	top = StringConverter::parseInt(opt->second);
	161	// Window title
	162	opt = miscParams->find("title");
	163	if(opt != miscParams->end())
	164	title = opt->second;
	165	// parentWindowHandle -> parentHWnd
	166	opt = miscParams->find("parentWindowHandle");
	167	if(opt != miscParams->end())
	168	parentHWnd = (HWND)StringConverter::parseUnsignedInt(opt->second);
	169	// externalWindowHandle -> externalHandle
	170	opt = miscParams->find("externalWindowHandle");
	171	if(opt != miscParams->end())
	172	externalHandle = (HWND)StringConverter::parseUnsignedInt(opt->second);
	173	// vsync [parseBool]
	174	opt = miscParams->find("vsync");
	175	if(opt != miscParams->end())
	176	mVSync = StringConverter::parseBool(opt->second);
	177	// displayFrequency
	178	opt = miscParams->find("displayFrequency");
	179	if(opt != miscParams->end())
	180	displayFrequency = StringConverter::parseUnsignedInt(opt->second);
	181	// colourDepth
	182	opt = miscParams->find("colourDepth");
	183	if(opt != miscParams->end())
	184	colourDepth = StringConverter::parseUnsignedInt(opt->second);
	185	// depthBuffer [parseBool]
	186	opt = miscParams->find("depthBuffer");
	187	if(opt != miscParams->end())
	188	depthBuffer = StringConverter::parseBool(opt->second);
	189	// FSAA type
	190	opt = miscParams->find("FSAA");
	191	if(opt != miscParams->end())
	192	mFSAAType = (D3DMULTISAMPLE_TYPE)StringConverter::parseUnsignedInt(opt->second);
	193	// FSAA quality
	194	opt = miscParams->find("FSAAQuality");
	195	if(opt != miscParams->end())
	196	mFSAAQuality = StringConverter::parseUnsignedInt(opt->second);
	197	// window border style
	198	opt = miscParams->find("border");
	199	if(opt != miscParams->end())
	200	border = opt->second;
	201	// set outer dimensions?
	202	opt = miscParams->find("outerDimensions");
	203	if(opt != miscParams->end())
	204	outerSize = StringConverter::parseBool(opt->second);
	205	// NV perf HUD?
	206	opt = miscParams->find("useNVPerfHUD");
	207	if(opt != miscParams->end())
	208	mUseNVPerfHUD = StringConverter::parseBool(opt->second);
	209
	210	}
	211
	212	// Destroy current window if any
	213	if( mHWnd )
	214	destroy();
	215
	216
	217	if (!externalHandle)
	218	{
	219	DWORD dwStyle = WS_VISIBLE \| WS_CLIPCHILDREN \| WS_CLIPSIBLINGS;
	220	RECT rc;
	221
	222	mWidth = width;
	223	mHeight = height;
	224	mTop = top;
	225	mLeft = left;
	226
	227	if (!fullScreen)
	228	{
	229	if (parentHWnd)
	230	{
	231	dwStyle \|= WS_CHILD;
	232	}
	233	else
	234	{
	235	if (border == "none")
	236	dwStyle \|= WS_POPUP;
	237	else if (border == "fixed")
	238	dwStyle \|= WS_OVERLAPPED \| WS_BORDER \| WS_CAPTION \|
	239	WS_SYSMENU \| WS_MINIMIZEBOX;
	240	else
	241	dwStyle \|= WS_OVERLAPPEDWINDOW;
	242	}
	243
	244	if (!outerSize)
	245	{
	246	// Calculate window dimensions required
	247	// to get the requested client area
	248	SetRect(&rc, 0, 0, mWidth, mHeight);
	249	AdjustWindowRect(&rc, dwStyle, false);
	250	mWidth = rc.right - rc.left;
	251	mHeight = rc.bottom - rc.top;
	252
	253	// Clamp width and height to the desktop dimensions
	254	int screenw = GetSystemMetrics(SM_CXSCREEN);
	255	int screenh = GetSystemMetrics(SM_CYSCREEN);
	256	if ((int)mWidth > screenw)
	257	mWidth = screenw;
	258	if ((int)mHeight > screenh)
	259	mHeight = screenh;
	260	if (mLeft < 0)
	261	mLeft = (screenw - mWidth) / 2;
	262	if (mTop < 0)
	263	mTop = (screenh - mHeight) / 2;
	264	}
	265	}
	266	else
	267	{
	268	dwStyle \|= WS_POPUP;
	269	mTop = mLeft = 0;
	270	}
	271
	272	// Register the window class
	273	// NB allow 4 bytes of window data for D3D9RenderWindow pointer
	274	WNDCLASS wc = { 0, WndProc, 0, 0, hInst,
	275	LoadIcon(0, IDI_APPLICATION), LoadCursor(NULL, IDC_ARROW),
	276	(HBRUSH)GetStockObject(BLACK_BRUSH), 0, "OgreD3D9Wnd" };
	277	RegisterClass(&wc);
	278
	279	// Create our main window
	280	// Pass pointer to self
	281	mIsExternal = false;
	282	mHWnd = CreateWindow("OgreD3D9Wnd", title.c_str(), dwStyle,
	283	mLeft, mTop, mWidth, mHeight, parentHWnd, 0, hInst, this);
	284	}
	285	else
	286	{
	287	mHWnd = externalHandle;
	288	mIsExternal = true;
	289	}
	290
	291	RECT rc;
	292	// top and left represent outer window coordinates
	293	GetWindowRect(mHWnd, &rc);
	294	mTop = rc.top;
	295	mLeft = rc.left;
	296	// width and height represent interior drawable area
	297	GetClientRect(mHWnd, &rc);
	298	mWidth = rc.right;
	299	mHeight = rc.bottom;
	300
	301	mName = name;
	302	mIsDepthBuffered = depthBuffer;
	303	mIsFullScreen = fullScreen;
	304	mColourDepth = colourDepth;
	305
	306	StringUtil::StrStreamType str;
	307	str << "D3D9 : Created D3D9 Rendering Window '"
	308	<< mName << "' : " << mWidth << "x" << mHeight
	309	<< ", " << mColourDepth << "bpp";
	310	LogManager::getSingleton().logMessage(
	311	LML_NORMAL, str.str());
	312
	313	createD3DResources();
	314
	315	mActive = true;
	316	}
	317
	318	void D3D9RenderWindow::createD3DResources(void)
	319	{
	320	// access device via driver
	321	LPDIRECT3DDEVICE9 mpD3DDevice = mDriver->getD3DDevice();
	322
	323	if (mIsSwapChain && !mpD3DDevice)
	324	{
	325	OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
	326	"Secondary window has not been given the device from the primary!",
	327	"D3D9RenderWindow::createD3DResources");
	328	}
	329
	330	// Set up the presentation parameters
	331	HRESULT hr;
	332	LPDIRECT3D9 pD3D = mDriver->getD3D();
	333	D3DDEVTYPE devType = D3DDEVTYPE_HAL;
	334
	335	ZeroMemory( &md3dpp, sizeof(D3DPRESENT_PARAMETERS) );
	336	md3dpp.Windowed = !mIsFullScreen;
	337	md3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	338	// triple buffer if VSync is on
	339	md3dpp.BackBufferCount = mVSync ? 2 : 1;
	340	md3dpp.EnableAutoDepthStencil = mIsDepthBuffered;
	341	md3dpp.hDeviceWindow = mHWnd;
	342	md3dpp.BackBufferWidth = mWidth;
	343	md3dpp.BackBufferHeight = mHeight;
	344
	345	if (mVSync)
	346	{
	347	md3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
	348	}
	349	else
	350	{
	351	// NB not using vsync in windowed mode in D3D9 can cause jerking at low
	352	// frame rates no matter what buffering modes are used (odd - perhaps a
	353	// timer issue in D3D9 since GL doesn't suffer from this)
	354	// low is < 200fps in this context
	355	if (!mIsFullScreen)
	356	{
	357	LogManager::getSingleton().logMessage("D3D9 : WARNING - "
	358	"disabling VSync in windowed mode can cause timing issues at lower "
	359	"frame rates, turn VSync on if you observe this problem.");
	360	}
	361	md3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
	362	}
	363
	364	md3dpp.BackBufferFormat = D3DFMT_R5G6B5;
	365	if( mColourDepth > 16 )
	366	md3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
	367
	368	if (mColourDepth > 16 )
	369	{
	370	// Try to create a 32-bit depth, 8-bit stencil
	371	if( FAILED( pD3D->CheckDeviceFormat(mDriver->getAdapterNumber(),
	372	devType, md3dpp.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL,
	373	D3DRTYPE_SURFACE, D3DFMT_D24S8 )))
	374	{
	375	// Bugger, no 8-bit hardware stencil, just try 32-bit zbuffer
	376	if( FAILED( pD3D->CheckDeviceFormat(mDriver->getAdapterNumber(),
	377	devType, md3dpp.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL,
	378	D3DRTYPE_SURFACE, D3DFMT_D32 )))
	379	{
	380	// Jeez, what a naff card. Fall back on 16-bit depth buffering
	381	md3dpp.AutoDepthStencilFormat = D3DFMT_D16;
	382	}
	383	else
	384	md3dpp.AutoDepthStencilFormat = D3DFMT_D32;
	385	}
	386	else
	387	{
	388	// Woohoo!
	389	if( SUCCEEDED( pD3D->CheckDepthStencilMatch( mDriver->getAdapterNumber(), devType,
	390	md3dpp.BackBufferFormat, md3dpp.BackBufferFormat, D3DFMT_D24S8 ) ) )
	391	{
	392	md3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
	393	}
	394	else
	395	md3dpp.AutoDepthStencilFormat = D3DFMT_D24X8;
	396	}
	397	}
	398	else
	399	// 16-bit depth, software stencil
	400	md3dpp.AutoDepthStencilFormat = D3DFMT_D16;
	401
	402	md3dpp.MultiSampleType = mFSAAType;
	403	md3dpp.MultiSampleQuality = (mFSAAQuality == 0) ? 0 : mFSAAQuality;
	404
	405	if (mIsSwapChain)
	406	{
	407	// Create swap chain
	408	hr = mpD3DDevice->CreateAdditionalSwapChain(
	409	&md3dpp, &mpSwapChain);
	410	if (FAILED(hr))
	411	{
	412	// Try a second time, may fail the first time due to back buffer count,
	413	// which will be corrected by the runtime
	414	hr = mpD3DDevice->CreateAdditionalSwapChain(
	415	&md3dpp, &mpSwapChain);
	416	}
	417	if (FAILED(hr))
	418	{
	419	OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
	420	"Unable to create an additional swap chain",
	421	"D3D9RenderWindow::createD3DResources");
	422	}
	423	// Store references to buffers for convenience
	424	mpSwapChain->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &mpRenderSurface );
	425	// Additional swap chains need their own depth buffer
	426	// to support resizing them
	427	if (mIsDepthBuffered)
	428	{
	429	hr = mpD3DDevice->CreateDepthStencilSurface(
	430	mWidth, mHeight,
	431	md3dpp.AutoDepthStencilFormat,
	432	md3dpp.MultiSampleType,
	433	md3dpp.MultiSampleQuality,
	434	(md3dpp.Flags & D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL),
	435	&mpRenderZBuffer, NULL
	436	);
	437
	438	if (FAILED(hr))
	439	{
	440	OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
	441	"Unable to create a depth buffer for the swap chain",
	442	"D3D9RenderWindow::createD3DResources");
	443
	444	}
	445	}
	446	else
	447	{
	448	mpRenderZBuffer = 0;
	449	}
	450	// release immediately so we don't hog them
	451	mpRenderSurface->Release();
	452	// We'll need the depth buffer for rendering the swap chain
	453	//mpRenderZBuffer->Release();
	454	}
	455	else
	456	{
	457	if (!mpD3DDevice)
	458	{
	459	// We haven't created the device yet, this must be the first time
	460
	461	// Do we want to preserve the FPU mode? Might be useful for scientific apps
	462	DWORD extraFlags = 0;
	463	ConfigOptionMap& options = Root::getSingleton().getRenderSystem()->getConfigOptions();
	464	ConfigOptionMap::iterator opti = options.find("Floating-point mode");
	465	if (opti != options.end() && opti->second.currentValue == "Consistent")
	466	extraFlags \|= D3DCREATE_FPU_PRESERVE;
	467
	468	// Set default settings (use the one Ogre discovered as a default)
	469	UINT adapterToUse = mDriver->getAdapterNumber();
	470
	471	if (mUseNVPerfHUD)
	472	{
	473	// Look for 'NVIDIA NVPerfHUD' adapter
	474	// If it is present, override default settings
	475	for (UINT adapter=0; adapter < mDriver->getD3D()->GetAdapterCount(); ++adapter)
	476	{
	477	D3DADAPTER_IDENTIFIER9 identifier;
	478	HRESULT res;
	479	res = mDriver->getD3D()->GetAdapterIdentifier(adapter,0,&identifier);
	480	if (strcmp(identifier.Description,"NVIDIA NVPerfHUD") == 0)
	481	{
	482	adapterToUse = adapter;
	483	devType = D3DDEVTYPE_REF;
	484	break;
	485	}
	486	}
	487	}
	488
	489	hr = pD3D->CreateDevice(adapterToUse, devType, mHWnd,
	490	D3DCREATE_HARDWARE_VERTEXPROCESSING \| extraFlags, &md3dpp, &mpD3DDevice );
	491	if (FAILED(hr))
	492	{
	493	// Try a second time, may fail the first time due to back buffer count,
	494	// which will be corrected down to 1 by the runtime
	495	hr = pD3D->CreateDevice( adapterToUse, devType, mHWnd,
	496	D3DCREATE_HARDWARE_VERTEXPROCESSING \| extraFlags, &md3dpp, &mpD3DDevice );
	497	}
	498	if( FAILED( hr ) )
	499	{
	500	hr = pD3D->CreateDevice( adapterToUse, devType, mHWnd,
	501	D3DCREATE_MIXED_VERTEXPROCESSING \| extraFlags, &md3dpp, &mpD3DDevice );
	502	if( FAILED( hr ) )
	503	{
	504	hr = pD3D->CreateDevice( adapterToUse, devType, mHWnd,
	505	D3DCREATE_SOFTWARE_VERTEXPROCESSING \| extraFlags, &md3dpp, &mpD3DDevice );
	506	}
	507	}
	508	// TODO: make this a bit better e.g. go from pure vertex processing to software
	509	if( FAILED( hr ) )
	510	{
	511	destroy();
	512	OGRE_EXCEPT( hr, "Failed to create Direct3D9 Device: " +
	513	Root::getSingleton().getErrorDescription(hr),
	514	"D3D9RenderWindow::createD3DResources" );
	515	}
	516	}
	517	// update device in driver
	518	mDriver->setD3DDevice( mpD3DDevice );
	519	// Store references to buffers for convenience
	520	mpD3DDevice->GetRenderTarget( 0, &mpRenderSurface );
	521	mpD3DDevice->GetDepthStencilSurface( &mpRenderZBuffer );
	522	// release immediately so we don't hog them
	523	mpRenderSurface->Release();
	524	mpRenderZBuffer->Release();
	525	}
	526
	527	}
	528
	529	void D3D9RenderWindow::destroyD3DResources()
	530	{
	531	mpRenderSurface = 0;
	532	if (mIsSwapChain)
	533	{
	534	SAFE_RELEASE(mpRenderZBuffer);
	535	SAFE_RELEASE(mpSwapChain);
	536	}
	537	else
	538	{
	539	// ignore depth buffer, access device through driver
	540	mpRenderZBuffer = 0;
	541	}
	542	}
	543
	544	void D3D9RenderWindow::destroy()
	545	{
	546	if (mHWnd && !mIsExternal)
	547	DestroyWindow(mHWnd);
	548	mHWnd = 0;
	549	mActive = false;
	550	}
	551
	552	bool D3D9RenderWindow::isVisible() const
	553	{
	554	return (mHWnd && !IsIconic(mHWnd));
	555	}
	556
	557	void D3D9RenderWindow::reposition(int top, int left)
	558	{
	559	if (mHWnd && !mIsFullScreen)
	560	{
	561	SetWindowPos(mHWnd, 0, top, left, 0, 0,
	562	SWP_NOSIZE \| SWP_NOZORDER \| SWP_NOACTIVATE);
	563	}
	564	}
	565
	566	void D3D9RenderWindow::resize(unsigned int width, unsigned int height)
	567	{
	568	if (mHWnd && !mIsFullScreen)
	569	{
	570	RECT rc = { 0, 0, width, height };
	571	AdjustWindowRect(&rc, GetWindowLong(mHWnd, GWL_STYLE), false);
	572	width = rc.right - rc.left;
	573	height = rc.bottom - rc.top;
	574	SetWindowPos(mHWnd, 0, 0, 0, width, height,
	575	SWP_NOMOVE \| SWP_NOZORDER \| SWP_NOACTIVATE);
	576	}
	577	}
	578
	579	void D3D9RenderWindow::windowMovedOrResized()
	580	{
	581	if (!mHWnd \|\| IsIconic(mHWnd))
	582	return;
	583
	584	RECT rc;
	585	// top and left represent outer window position
	586	GetWindowRect(mHWnd, &rc);
	587	mTop = rc.top;
	588	mLeft = rc.left;
	589	// width and height represent drawable area only
	590	GetClientRect(mHWnd, &rc);
	591	unsigned int width = rc.right;
	592	unsigned int height = rc.bottom;
	593	if (mWidth == width && mHeight == height)
	594	return;
	595
	596	if (mIsSwapChain)
	597	{
	598
	599	D3DPRESENT_PARAMETERS pp = md3dpp;
	600
	601	pp.BackBufferWidth = width;
	602	pp.BackBufferHeight = height;
	603
	604	SAFE_RELEASE( mpRenderZBuffer );
	605	SAFE_RELEASE( mpSwapChain );
	606
	607	HRESULT hr = mDriver->getD3DDevice()->CreateAdditionalSwapChain(
	608	&pp,
	609	&mpSwapChain);
	610
	611	if (FAILED(hr))
	612	{
	613	StringUtil::StrStreamType str;
	614	str << "D3D9RenderWindow: failed to reset device to new dimensions << "
	615	<< width << " x " << height << ". Trying to recover.";
	616	LogManager::getSingleton().logMessage(LML_CRITICAL, str.str());
	617
	618	// try to recover
	619	hr = mDriver->getD3DDevice()->CreateAdditionalSwapChain(
	620	&md3dpp,
	621	&mpSwapChain);
	622
	623	if (FAILED(hr))
	624	OGRE_EXCEPT( hr, "Reset window to last size failed", "D3D9RenderWindow::resize" );
	625
	626	}
	627	else
	628	{
	629	md3dpp = pp;
	630
	631	mWidth = width;
	632	mHeight = height;
	633
	634	hr = mpSwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &mpRenderSurface);
	635	hr = mDriver->getD3DDevice()->CreateDepthStencilSurface(
	636	mWidth, mHeight,
	637	md3dpp.AutoDepthStencilFormat,
	638	md3dpp.MultiSampleType,
	639	md3dpp.MultiSampleQuality,
	640	(md3dpp.Flags & D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL),
	641	&mpRenderZBuffer, NULL
	642	);
	643
	644	if (FAILED(hr))
	645	{
	646	OGRE_EXCEPT( hr, "Failed to create depth stencil surface for Swap Chain", "D3D9RenderWindow::resize" );
	647	}
	648
	649	mpRenderSurface->Release();
	650	}
	651	}
	652	// primary windows must reset the device
	653	else
	654	{
	655	md3dpp.BackBufferWidth = mWidth = width;
	656	md3dpp.BackBufferHeight = mHeight = height;
	657	static_cast<D3D9RenderSystem*>(
	658	Root::getSingleton().getRenderSystem())->_notifyDeviceLost();
	659	}
	660
	661	// Notify viewports of resize
	662	ViewportList::iterator it = mViewportList.begin();
	663	while( it != mViewportList.end() )
	664	(*it++).second->_updateDimensions();
	665	}
	666
	667	void D3D9RenderWindow::swapBuffers( bool waitForVSync )
	668	{
	669	// access device through driver
	670	LPDIRECT3DDEVICE9 mpD3DDevice = mDriver->getD3DDevice();
	671	if( mpD3DDevice )
	672	{
	673	HRESULT hr;
	674	if (mIsSwapChain)
	675	{
	676	hr = mpSwapChain->Present(NULL, NULL, NULL, NULL, 0);
	677	}
	678	else
	679	{
	680	hr = mpD3DDevice->Present( NULL, NULL, 0, NULL );
	681	}
	682	if( D3DERR_DEVICELOST == hr )
	683	{
	684	static_cast<D3D9RenderSystem*>(
	685	Root::getSingleton().getRenderSystem())->_notifyDeviceLost();
	686	}
	687	else if( FAILED(hr) )
	688	OGRE_EXCEPT( hr, "Error Presenting surfaces", "D3D9RenderWindow::swapBuffers" );
	689	}
	690	}
	691
	692	void D3D9RenderWindow::getCustomAttribute( const String& name, void* pData )
	693	{
	694	// Valid attributes and their equvalent native functions:
	695	// D3DDEVICE : getD3DDevice
	696	// HWND : getWindowHandle
	697
	698	if( name == "D3DDEVICE" )
	699	{
	700	LPDIRECT3DDEVICE9 pDev = (LPDIRECT3DDEVICE9)pData;
	701	*pDev = getD3DDevice();
	702	return;
	703	}
	704	else if( name == "HWND" )
	705	{
	706	HWND pHwnd = (HWND)pData;
	707	*pHwnd = getWindowHandle();
	708	return;
	709	}
	710	else if( name == "isTexture" )
	711	{
	712	bool b = reinterpret_cast< bool >( pData );
	713	*b = false;
	714
	715	return;
	716	}
	717	else if( name == "D3DZBUFFER" )
	718	{
	719	LPDIRECT3DSURFACE9 pSurf = (LPDIRECT3DSURFACE9)pData;
	720	*pSurf = mpRenderZBuffer;
	721	return;
	722	}
	723	else if( name == "DDBACKBUFFER" )
	724	{
	725	LPDIRECT3DSURFACE9 pSurf = (LPDIRECT3DSURFACE9)pData;
	726	*pSurf = mpRenderSurface;
	727	return;
	728	}
	729	else if( name == "DDFRONTBUFFER" )
	730	{
	731	LPDIRECT3DSURFACE9 pSurf = (LPDIRECT3DSURFACE9)pData;
	732	*pSurf = mpRenderSurface;
	733	return;
	734	}
	735	}
	736
	737	void D3D9RenderWindow::writeContentsToFile(const String& filename)
	738	{
	739	HRESULT hr;
	740	LPDIRECT3DSURFACE9 pSurf=NULL, pTempSurf=NULL;
	741	D3DSURFACE_DESC desc;
	742	D3DDISPLAYMODE dm;
	743
	744	// access device through driver
	745	LPDIRECT3DDEVICE9 mpD3DDevice = mDriver->getD3DDevice();
	746
	747	// get display dimensions
	748	// this will be the dimensions of the front buffer
	749	if (FAILED(hr = mpD3DDevice->GetDisplayMode(0, &dm)))
	750	OGRE_EXCEPT(hr, "Can't get display mode!", "D3D9RenderWindow::writeContentsToFile");
	751
	752	desc.Width = dm.Width;
	753	desc.Height = dm.Height;
	754	desc.Format = D3DFMT_A8R8G8B8;
	755	if (FAILED(hr = mpD3DDevice->CreateOffscreenPlainSurface(
	756	desc.Width,
	757	desc.Height,
	758	desc.Format,
	759	D3DPOOL_SYSTEMMEM,
	760	&pTempSurf,
	761	NULL)))
	762	{
	763	OGRE_EXCEPT(hr, "Cannot create offscreen buffer 1!", "D3D9RenderWindow::writeContentsToFile");
	764	}
	765
	766	if (FAILED(hr = mpD3DDevice->GetFrontBufferData(0, pTempSurf)))
	767	{
	768	SAFE_RELEASE(pTempSurf);
	769	OGRE_EXCEPT(hr, "Can't get front buffer!", "D3D9RenderWindow::writeContentsToFile");
	770	}
	771
	772	D3DLOCKED_RECT lockedRect;
	773	if(mIsFullScreen)
	774	{
	775	if (FAILED(hr = pTempSurf->LockRect(&lockedRect, NULL,
	776	D3DLOCK_READONLY \| D3DLOCK_NOSYSLOCK)))
	777	{
	778	OGRE_EXCEPT(hr, "can't lock rect!", "D3D9RenderWindow::writeContentsToFile");
	779	}
	780	}
	781	else
	782	{
	783	RECT srcRect;
	784	GetWindowRect(mHWnd, &srcRect);
	785
	786	desc.Width = srcRect.right - srcRect.left;
	787	desc.Height = srcRect.bottom - srcRect.top;
	788
	789	if (FAILED(hr = pTempSurf->LockRect(&lockedRect, &srcRect,
	790
	791	D3DLOCK_READONLY \| D3DLOCK_NOSYSLOCK)))
	792	{
	793	OGRE_EXCEPT(hr, "can't lock rect!", "D3D9RenderWindow::writeContentsToFile");
	794	}
	795	}
	796
	797	ImageCodec::ImageData *imgData = new ImageCodec::ImageData();
	798	imgData->width = desc.Width;
	799	imgData->height = desc.Height;
	800	imgData->format = PF_BYTE_RGB;
	801
	802	// Allocate contiguous buffer (surfaces aren't necessarily contiguous)
	803	uchar* pBuffer = new uchar[desc.Width * desc.Height * 3];
	804
	805	uint x, y;
	806	uchar pData, pDest;
	807
	808	pData = (uchar*)lockedRect.pBits;
	809	pDest = pBuffer;
	810	for (y = 0; y < desc.Height; ++y)
	811	{
	812	uchar *pRow = pData;
	813
	814	for (x = 0; x < desc.Width; ++x)
	815	{
	816	switch(desc.Format)
	817	{
	818	case D3DFMT_R5G6B5:
	819	WORD val;
	820
	821	val = ((WORD)pRow);
	822	pRow += 2;
	823
	824	*pDest++ = Bitwise::convertBitPattern((WORD)val, (WORD)0xF800, (BYTE)0xFF);
	825	*pDest++ = Bitwise::convertBitPattern((WORD)val, (WORD)0x07E0, (BYTE)0xFF);
	826	*pDest++ = Bitwise::convertBitPattern((WORD)val, (WORD)0x001F, (BYTE)0xFF);
	827	break;
	828	case D3DFMT_A8R8G8B8:
	829	case D3DFMT_X8R8G8B8:
	830	// Actual format is BRGA for some reason
	831	*pDest++ = pRow[2]; // R
	832	*pDest++ = pRow[1]; // G
	833	*pDest++ = pRow[0]; // B
	834	pRow += 4; // skip alpha / dummy
	835	break;
	836	case D3DFMT_R8G8B8:
	837	// Actual format is BRGA for some reason
	838	*pDest++ = pRow[2]; // R
	839	*pDest++ = pRow[1]; // G
	840	*pDest++ = pRow[0]; // B
	841	pRow += 3;
	842	break;
	843	}
	844
	845
	846	}
	847	// increase by one line
	848	pData += lockedRect.Pitch;
	849	}
	850
	851	// Wrap buffer in a chunk
	852	MemoryDataStreamPtr stream(new MemoryDataStream(pBuffer, desc.Width * desc.Height * 3, false));
	853
	854	// Get codec
	855	size_t pos = filename.find_last_of(".");
	856	String extension;
	857	if( pos == String::npos )
	858	OGRE_EXCEPT(
	859	Exception::ERR_INVALIDPARAMS,
	860	"Unable to determine image type for '" + filename + "' - invalid extension.",
	861	"D3D9RenderWindow::writeContentsToFile" );
	862
	863	while( pos != filename.length() - 1 )
	864	extension += filename[++pos];
	865
	866	// Get the codec
	867	Codec * pCodec = Codec::getCodec(extension);
	868
	869	// Write out
	870	{
	871	Codec::CodecDataPtr ptr(imgData);
	872	pCodec->codeToFile(stream, filename, ptr);
	873	}
	874
	875	delete [] pBuffer;
	876
	877	SAFE_RELEASE(pTempSurf);
	878	SAFE_RELEASE(pSurf);
	879	}
	880	//-----------------------------------------------------------------------------
	881	void D3D9RenderWindow::update(bool swap)
	882	{
	883	D3D9RenderSystem* rs = static_cast<D3D9RenderSystem*>(
	884	Root::getSingleton().getRenderSystem());
	885
	886	// access device through driver
	887	LPDIRECT3DDEVICE9 mpD3DDevice = mDriver->getD3DDevice();
	888
	889	if (rs->isDeviceLost())
	890	{
	891	// Test the cooperative mode first
	892	HRESULT hr = mpD3DDevice->TestCooperativeLevel();
	893	if (hr == D3DERR_DEVICELOST)
	894	{
	895	// device lost, and we can't reset
	896	// can't do anything about it here, wait until we get
	897	// D3DERR_DEVICENOTRESET; rendering calls will silently fail until
	898	// then (except Present, but we ignore device lost there too)
	899	mpRenderSurface = 0;
	900	// need to release if swap chain
	901	if (!mIsSwapChain)
	902	mpRenderZBuffer = 0;
	903	else
	904	SAFE_RELEASE (mpRenderZBuffer);
	905	Sleep(50);
	906	return;
	907	}
	908	else
	909	{
	910	// device lost, and we can reset
	911	rs->restoreLostDevice();
	912
	913	// Still lost?
	914	if (rs->isDeviceLost())
	915	{
	916	// Wait a while
	917	Sleep(50);
	918	return;
	919	}
	920
	921	// fixed: this only works for not swap chained
	922	if (!mIsSwapChain)
	923	{
	924	// re-qeuery buffers
	925	mpD3DDevice->GetRenderTarget( 0, &mpRenderSurface );
	926	mpD3DDevice->GetDepthStencilSurface( &mpRenderZBuffer );
	927	// release immediately so we don't hog them
	928	mpRenderSurface->Release();
	929	mpRenderZBuffer->Release();
	930	}
	931	else
	932	{
	933	mpSwapChain->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &mpRenderSurface );
	934	if (mIsDepthBuffered) {
	935	hr = mpD3DDevice->CreateDepthStencilSurface(
	936	mWidth, mHeight,
	937	md3dpp.AutoDepthStencilFormat,
	938	md3dpp.MultiSampleType,
	939	md3dpp.MultiSampleQuality,
	940	(md3dpp.Flags & D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL),
	941	&mpRenderZBuffer, NULL
	942	);
	943
	944	if (FAILED(hr)) {
	945	OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
	946	"Unable to re-create depth buffer for the swap chain",
	947	"D3D9RenderWindow::update");
	948
	949	}
	950	}
	951	else
	952	{
	953	mpRenderZBuffer = 0;
	954	}
	955
	956	// release immediately so we don't hog them
	957	mpRenderSurface->Release();
	958	}
	959	}
	960
	961	}
	962	RenderWindow::update(swap);
	963	}
	964	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: OGRE/trunk/ogrenew/RenderSystems/Direct3D9/src/OgreD3D9RenderWindow.cpp @ 692

Download in other formats: