Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/RenderSystems/Direct3D9/src/OgreD3D9RenderWindow.cpp @ 3

Last change on this file since 3 was 3, checked in by anonymous, 17 years ago
=update
File size: 28.8 KB

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

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

Download in other formats: