Context Navigation

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

Revision 657, 29.3 KB checked in by mattausch, 19 years ago (diff)
added ogre dependencies and patched ogre sources

Rev	Line
[657]	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
	148	if(miscParams)
	149	{
	150	// Get variable-length params
	151	NameValuePairList::const_iterator opt;
	152	// left (x)
	153	opt = miscParams->find("left");
	154	if(opt != miscParams->end())
	155	left = StringConverter::parseInt(opt->second);
	156	// top (y)
	157	opt = miscParams->find("top");
	158	if(opt != miscParams->end())
	159	top = StringConverter::parseInt(opt->second);
	160	// Window title
	161	opt = miscParams->find("title");
	162	if(opt != miscParams->end())
	163	title = opt->second;
	164	// parentWindowHandle -> parentHWnd
	165	opt = miscParams->find("parentWindowHandle");
	166	if(opt != miscParams->end())
	167	parentHWnd = (HWND)StringConverter::parseUnsignedInt(opt->second);
	168	// externalWindowHandle -> externalHandle
	169	opt = miscParams->find("externalWindowHandle");
	170	if(opt != miscParams->end())
	171	externalHandle = (HWND)StringConverter::parseUnsignedInt(opt->second);
	172	// vsync [parseBool]
	173	opt = miscParams->find("vsync");
	174	if(opt != miscParams->end())
	175	mVSync = StringConverter::parseBool(opt->second);
	176	// displayFrequency
	177	opt = miscParams->find("displayFrequency");
	178	if(opt != miscParams->end())
	179	displayFrequency = StringConverter::parseUnsignedInt(opt->second);
	180	// colourDepth
	181	opt = miscParams->find("colourDepth");
	182	if(opt != miscParams->end())
	183	colourDepth = StringConverter::parseUnsignedInt(opt->second);
	184	// depthBuffer [parseBool]
	185	opt = miscParams->find("depthBuffer");
	186	if(opt != miscParams->end())
	187	depthBuffer = StringConverter::parseBool(opt->second);
	188	// FSAA type
	189	opt = miscParams->find("FSAA");
	190	if(opt != miscParams->end())
	191	mFSAAType = (D3DMULTISAMPLE_TYPE)StringConverter::parseUnsignedInt(opt->second);
	192	// FSAA quality
	193	opt = miscParams->find("FSAAQuality");
	194	if(opt != miscParams->end())
	195	mFSAAQuality = StringConverter::parseUnsignedInt(opt->second);
	196	// window border style
	197	opt = miscParams->find("border");
	198	if(opt != miscParams->end())
	199	border = opt->second;
	200	// set outer dimensions?
	201	opt = miscParams->find("outerDimensions");
	202	if(opt != miscParams->end())
	203	outerSize = StringConverter::parseBool(opt->second);
	204	}
	205
	206	// Destroy current window if any
	207	if( mHWnd )
	208	destroy();
	209
	210
	211	if (!externalHandle)
	212	{
	213	DWORD dwStyle = WS_VISIBLE \| WS_CLIPCHILDREN \| WS_CLIPSIBLINGS;
	214	RECT rc;
	215
	216	mWidth = width;
	217	mHeight = height;
	218	mTop = top;
	219	mLeft = left;
	220
	221	if (!fullScreen)
	222	{
	223	if (parentHWnd)
	224	{
	225	dwStyle \|= WS_CHILD;
	226	}
	227	else
	228	{
	229	if (border == "none")
	230	dwStyle \|= WS_POPUP;
	231	else if (border == "fixed")
	232	dwStyle \|= WS_OVERLAPPED \| WS_BORDER \| WS_CAPTION \|
	233	WS_SYSMENU \| WS_MINIMIZEBOX;
	234	else
	235	dwStyle \|= WS_OVERLAPPEDWINDOW;
	236	}
	237
	238	if (!outerSize)
	239	{
	240	// Calculate window dimensions required
	241	// to get the requested client area
	242	SetRect(&rc, 0, 0, mWidth, mHeight);
	243	AdjustWindowRect(&rc, dwStyle, false);
	244	mWidth = rc.right - rc.left;
	245	mHeight = rc.bottom - rc.top;
	246
	247	// Clamp width and height to the desktop dimensions
	248	int screenw = GetSystemMetrics(SM_CXSCREEN);
	249	int screenh = GetSystemMetrics(SM_CYSCREEN);
	250	if ((int)mWidth > screenw)
	251	mWidth = screenw;
	252	if ((int)mHeight > screenh)
	253	mHeight = screenh;
	254	if (mLeft < 0)
	255	mLeft = (screenw - mWidth) / 2;
	256	if (mTop < 0)
	257	mTop = (screenh - mHeight) / 2;
	258	}
	259	}
	260	else
	261	{
	262	dwStyle \|= WS_POPUP;
	263	mTop = mLeft = 0;
	264	}
	265
	266	// Register the window class
	267	// NB allow 4 bytes of window data for D3D9RenderWindow pointer
	268	WNDCLASS wc = { 0, WndProc, 0, 0, hInst,
	269	LoadIcon(0, IDI_APPLICATION), LoadCursor(NULL, IDC_ARROW),
	270	(HBRUSH)GetStockObject(BLACK_BRUSH), 0, "OgreD3D9Wnd" };
	271	RegisterClass(&wc);
	272
	273	// Create our main window
	274	// Pass pointer to self
	275	mIsExternal = false;
	276	mHWnd = CreateWindow("OgreD3D9Wnd", title.c_str(), dwStyle,
	277	mLeft, mTop, mWidth, mHeight, parentHWnd, 0, hInst, this);
	278	}
	279	else
	280	{
	281	mHWnd = externalHandle;
	282	mIsExternal = true;
	283	}
	284
	285	RECT rc;
	286	// top and left represent outer window coordinates
	287	GetWindowRect(mHWnd, &rc);
	288	mTop = rc.top;
	289	mLeft = rc.left;
	290	// width and height represent interior drawable area
	291	GetClientRect(mHWnd, &rc);
	292	mWidth = rc.right;
	293	mHeight = rc.bottom;
	294
	295	mName = name;
	296	mIsDepthBuffered = depthBuffer;
	297	mIsFullScreen = fullScreen;
	298	mColourDepth = colourDepth;
	299
	300	StringUtil::StrStreamType str;
	301	str << "D3D9 : Created D3D9 Rendering Window '"
	302	<< mName << "' : " << mWidth << "x" << mHeight
	303	<< ", " << mColourDepth << "bpp";
	304	LogManager::getSingleton().logMessage(
	305	LML_NORMAL, str.str());
	306
	307	createD3DResources();
	308
	309	mActive = true;
	310	}
	311
	312	void D3D9RenderWindow::createD3DResources(void)
	313	{
	314	// access device via driver
	315	LPDIRECT3DDEVICE9 mpD3DDevice = mDriver->getD3DDevice();
	316
	317	if (mIsSwapChain && !mpD3DDevice)
	318	{
	319	OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
	320	"Secondary window has not been given the device from the primary!",
	321	"D3D9RenderWindow::createD3DResources");
	322	}
	323
	324	// Set up the presentation parameters
	325	HRESULT hr;
	326	LPDIRECT3D9 pD3D = mDriver->getD3D();
	327	D3DDEVTYPE devType = D3DDEVTYPE_HAL;
	328
	329	ZeroMemory( &md3dpp, sizeof(D3DPRESENT_PARAMETERS) );
	330	md3dpp.Windowed = !mIsFullScreen;
	331	md3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	332	md3dpp.BackBufferCount = 1;
	333	md3dpp.EnableAutoDepthStencil = mIsDepthBuffered;
	334	md3dpp.hDeviceWindow = mHWnd;
	335	md3dpp.BackBufferWidth = mWidth;
	336	md3dpp.BackBufferHeight = mHeight;
	337
	338	if (mVSync)
	339	md3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
	340	else
	341	md3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
	342
	343	md3dpp.BackBufferFormat = D3DFMT_R5G6B5;
	344	if( mColourDepth > 16 )
	345	md3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
	346
	347	if (mColourDepth > 16 )
	348	{
	349	// Try to create a 32-bit depth, 8-bit stencil
	350	if( FAILED( pD3D->CheckDeviceFormat(mDriver->getAdapterNumber(),
	351	devType, md3dpp.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL,
	352	D3DRTYPE_SURFACE, D3DFMT_D24S8 )))
	353	{
	354	// Bugger, no 8-bit hardware stencil, just try 32-bit zbuffer
	355	if( FAILED( pD3D->CheckDeviceFormat(mDriver->getAdapterNumber(),
	356	devType, md3dpp.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL,
	357	D3DRTYPE_SURFACE, D3DFMT_D32 )))
	358	{
	359	// Jeez, what a naff card. Fall back on 16-bit depth buffering
	360	md3dpp.AutoDepthStencilFormat = D3DFMT_D16;
	361	}
	362	else
	363	md3dpp.AutoDepthStencilFormat = D3DFMT_D32;
	364	}
	365	else
	366	{
	367	// Woohoo!
	368	if( SUCCEEDED( pD3D->CheckDepthStencilMatch( mDriver->getAdapterNumber(), devType,
	369	md3dpp.BackBufferFormat, md3dpp.BackBufferFormat, D3DFMT_D24S8 ) ) )
	370	{
	371	md3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
	372	}
	373	else
	374	md3dpp.AutoDepthStencilFormat = D3DFMT_D24X8;
	375	}
	376	}
	377	else
	378	// 16-bit depth, software stencil
	379	md3dpp.AutoDepthStencilFormat = D3DFMT_D16;
	380
	381	md3dpp.MultiSampleType = mFSAAType;
	382	md3dpp.MultiSampleQuality = (mFSAAQuality == 0) ? 0 : mFSAAQuality;
	383
	384	if (mIsSwapChain)
	385	{
	386	// Create swap chain
	387	hr = mpD3DDevice->CreateAdditionalSwapChain(
	388	&md3dpp, &mpSwapChain);
	389	if (FAILED(hr))
	390	{
	391	OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
	392	"Unable to create an additional swap chain",
	393	"D3D9RenderWindow::createD3DResources");
	394
	395	}
	396	// Store references to buffers for convenience
	397	mpSwapChain->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &mpRenderSurface );
	398	// Additional swap chains need their own depth buffer
	399	// to support resizing them
	400	if (mIsDepthBuffered)
	401	{
	402	hr = mpD3DDevice->CreateDepthStencilSurface(
	403	mWidth, mHeight,
	404	md3dpp.AutoDepthStencilFormat,
	405	md3dpp.MultiSampleType,
	406	md3dpp.MultiSampleQuality,
	407	(md3dpp.Flags & D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL),
	408	&mpRenderZBuffer, NULL
	409	);
	410
	411	if (FAILED(hr))
	412	{
	413	OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
	414	"Unable to create a depth buffer for the swap chain",
	415	"D3D9RenderWindow::createD3DResources");
	416
	417	}
	418	}
	419	else
	420	{
	421	mpRenderZBuffer = 0;
	422	}
	423	// release immediately so we don't hog them
	424	mpRenderSurface->Release();
	425	// We'll need the depth buffer for rendering the swap chain
	426	//mpRenderZBuffer->Release();
	427	}
	428	else
	429	{
	430	if (!mpD3DDevice)
	431	{
	432	// We haven't created the device yet, this must be the first time
	433
	434	// Do we want to preserve the FPU mode? Might be useful for scientific apps
	435	DWORD extraFlags = 0;
	436	ConfigOptionMap& options = Root::getSingleton().getRenderSystem()->getConfigOptions();
	437	ConfigOptionMap::iterator opti = options.find("Floating-point mode");
	438	if (opti != options.end() && opti->second.currentValue == "Consistent")
	439	extraFlags \|= D3DCREATE_FPU_PRESERVE;
	440
	441	hr = pD3D->CreateDevice( mDriver->getAdapterNumber(), devType, mHWnd,
	442	D3DCREATE_HARDWARE_VERTEXPROCESSING \| extraFlags, &md3dpp, &mpD3DDevice );
	443	if( FAILED( hr ) )
	444	{
	445	hr = pD3D->CreateDevice( mDriver->getAdapterNumber(), devType, mHWnd,
	446	D3DCREATE_MIXED_VERTEXPROCESSING \| extraFlags, &md3dpp, &mpD3DDevice );
	447	if( FAILED( hr ) )
	448	{
	449	hr = pD3D->CreateDevice( mDriver->getAdapterNumber(), devType, mHWnd,
	450	D3DCREATE_SOFTWARE_VERTEXPROCESSING \| extraFlags, &md3dpp, &mpD3DDevice );
	451	}
	452	}
	453	// TODO: make this a bit better e.g. go from pure vertex processing to software
	454	if( FAILED( hr ) )
	455	{
	456	destroy();
	457	OGRE_EXCEPT( hr, "Failed to create Direct3D9 Device: " +
	458	Root::getSingleton().getErrorDescription(hr),
	459	"D3D9RenderWindow::createD3DResources" );
	460	}
	461	}
	462	// update device in driver
	463	mDriver->setD3DDevice( mpD3DDevice );
	464	// Store references to buffers for convenience
	465	mpD3DDevice->GetRenderTarget( 0, &mpRenderSurface );
	466	mpD3DDevice->GetDepthStencilSurface( &mpRenderZBuffer );
	467	// release immediately so we don't hog them
	468	mpRenderSurface->Release();
	469	mpRenderZBuffer->Release();
	470	}
	471
	472	}
	473
	474	void D3D9RenderWindow::destroyD3DResources()
	475	{
	476	mpRenderSurface = 0;
	477	if (mIsSwapChain)
	478	{
	479	SAFE_RELEASE(mpRenderZBuffer);
	480	SAFE_RELEASE(mpSwapChain);
	481	}
	482	else
	483	{
	484	// ignore depth buffer, access device through driver
	485	mpRenderZBuffer = 0;
	486	}
	487	}
	488
	489	void D3D9RenderWindow::destroy()
	490	{
	491	if (mHWnd && !mIsExternal)
	492	DestroyWindow(mHWnd);
	493	mHWnd = 0;
	494	mActive = false;
	495	}
	496
	497	bool D3D9RenderWindow::isVisible() const
	498	{
	499	return (mHWnd && !IsIconic(mHWnd));
	500	}
	501
	502	void D3D9RenderWindow::reposition(int top, int left)
	503	{
	504	if (mHWnd && !mIsFullScreen)
	505	{
	506	SetWindowPos(mHWnd, 0, top, left, 0, 0,
	507	SWP_NOSIZE \| SWP_NOZORDER \| SWP_NOACTIVATE);
	508	}
	509	}
	510
	511	void D3D9RenderWindow::resize(unsigned int width, unsigned int height)
	512	{
	513	if (mHWnd && !mIsFullScreen)
	514	{
	515	RECT rc = { 0, 0, width, height };
	516	AdjustWindowRect(&rc, GetWindowLong(mHWnd, GWL_STYLE), false);
	517	width = rc.right - rc.left;
	518	height = rc.bottom - rc.top;
	519	SetWindowPos(mHWnd, 0, 0, 0, width, height,
	520	SWP_NOMOVE \| SWP_NOZORDER \| SWP_NOACTIVATE);
	521	}
	522	}
	523
	524	void D3D9RenderWindow::windowMovedOrResized()
	525	{
	526	if (!mHWnd \|\| IsIconic(mHWnd))
	527	return;
	528
	529	RECT rc;
	530	// top and left represent outer window position
	531	GetWindowRect(mHWnd, &rc);
	532	mTop = rc.top;
	533	mLeft = rc.left;
	534	// width and height represent drawable area only
	535	GetClientRect(mHWnd, &rc);
	536	unsigned int width = rc.right;
	537	unsigned int height = rc.bottom;
	538	if (mWidth == width && mHeight == height)
	539	return;
	540
	541	if (mIsSwapChain)
	542	{
	543
	544	D3DPRESENT_PARAMETERS pp = md3dpp;
	545
	546	pp.BackBufferWidth = width;
	547	pp.BackBufferHeight = height;
	548
	549	SAFE_RELEASE( mpRenderZBuffer );
	550	SAFE_RELEASE( mpSwapChain );
	551
	552	HRESULT hr = mDriver->getD3DDevice()->CreateAdditionalSwapChain(
	553	&pp,
	554	&mpSwapChain);
	555
	556	if (FAILED(hr))
	557	{
	558	StringUtil::StrStreamType str;
	559	str << "D3D9RenderWindow: failed to reset device to new dimensions << "
	560	<< width << " x " << height << ". Trying to recover.";
	561	LogManager::getSingleton().logMessage(LML_CRITICAL, str.str());
	562
	563	// try to recover
	564	hr = mDriver->getD3DDevice()->CreateAdditionalSwapChain(
	565	&md3dpp,
	566	&mpSwapChain);
	567
	568	if (FAILED(hr))
	569	OGRE_EXCEPT( hr, "Reset window to last size failed", "D3D9RenderWindow::resize" );
	570
	571	}
	572	else
	573	{
	574	md3dpp = pp;
	575
	576	mWidth = width;
	577	mHeight = height;
	578
	579	hr = mpSwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &mpRenderSurface);
	580	hr = mDriver->getD3DDevice()->CreateDepthStencilSurface(
	581	mWidth, mHeight,
	582	md3dpp.AutoDepthStencilFormat,
	583	md3dpp.MultiSampleType,
	584	md3dpp.MultiSampleQuality,
	585	(md3dpp.Flags & D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL),
	586	&mpRenderZBuffer, NULL
	587	);
	588
	589	if (FAILED(hr))
	590	{
	591	OGRE_EXCEPT( hr, "Failed to create depth stencil surface for Swap Chain", "D3D9RenderWindow::resize" );
	592	}
	593
	594	mpRenderSurface->Release();
	595	}
	596	}
	597	// primary windows must reset the device
	598	else
	599	{
	600	md3dpp.BackBufferWidth = mWidth = width;
	601	md3dpp.BackBufferHeight = mHeight = height;
	602	static_cast<D3D9RenderSystem*>(
	603	Root::getSingleton().getRenderSystem())->_notifyDeviceLost();
	604	}
	605
	606	// Notify viewports of resize
	607	ViewportList::iterator it = mViewportList.begin();
	608	while( it != mViewportList.end() )
	609	(*it++).second->_updateDimensions();
	610	}
	611
	612	void D3D9RenderWindow::swapBuffers( bool waitForVSync )
	613	{
	614	// access device through driver
	615	LPDIRECT3DDEVICE9 mpD3DDevice = mDriver->getD3DDevice();
	616	if( mpD3DDevice )
	617	{
	618	HRESULT hr;
	619	if (mIsSwapChain)
	620	{
	621	hr = mpSwapChain->Present(NULL, NULL, NULL, NULL, 0);
	622	}
	623	else
	624	{
	625	hr = mpD3DDevice->Present( NULL, NULL, 0, NULL );
	626	}
	627	if( D3DERR_DEVICELOST == hr )
	628	{
	629	static_cast<D3D9RenderSystem*>(
	630	Root::getSingleton().getRenderSystem())->_notifyDeviceLost();
	631	}
	632	else if( FAILED(hr) )
	633	OGRE_EXCEPT( hr, "Error Presenting surfaces", "D3D9RenderWindow::swapBuffers" );
	634	}
	635	}
	636
	637	void D3D9RenderWindow::getCustomAttribute( const String& name, void* pData )
	638	{
	639	// Valid attributes and their equvalent native functions:
	640	// D3DDEVICE : getD3DDevice
	641	// HWND : getWindowHandle
	642
	643	if( name == "D3DDEVICE" )
	644	{
	645	LPDIRECT3DDEVICE9 pDev = (LPDIRECT3DDEVICE9)pData;
	646	*pDev = getD3DDevice();
	647	return;
	648	}
	649	else if( name == "HWND" )
	650	{
	651	HWND pHwnd = (HWND)pData;
	652	*pHwnd = getWindowHandle();
	653	return;
	654	}
	655	else if( name == "isTexture" )
	656	{
	657	bool b = reinterpret_cast< bool >( pData );
	658	*b = false;
	659
	660	return;
	661	}
	662	else if( name == "D3DZBUFFER" )
	663	{
	664	LPDIRECT3DSURFACE9 pSurf = (LPDIRECT3DSURFACE9)pData;
	665	*pSurf = mpRenderZBuffer;
	666	return;
	667	}
	668	else if( name == "DDBACKBUFFER" )
	669	{
	670	LPDIRECT3DSURFACE9 pSurf = (LPDIRECT3DSURFACE9)pData;
	671	*pSurf = mpRenderSurface;
	672	return;
	673	}
	674	else if( name == "DDFRONTBUFFER" )
	675	{
	676	LPDIRECT3DSURFACE9 pSurf = (LPDIRECT3DSURFACE9)pData;
	677	*pSurf = mpRenderSurface;
	678	return;
	679	}
	680	}
	681
	682	void D3D9RenderWindow::writeContentsToFile(const String& filename)
	683	{
	684	HRESULT hr;
	685	LPDIRECT3DSURFACE9 pSurf=NULL, pTempSurf=NULL;
	686	D3DSURFACE_DESC desc;
	687	D3DDISPLAYMODE dm;
	688
	689	// access device through driver
	690	LPDIRECT3DDEVICE9 mpD3DDevice = mDriver->getD3DDevice();
	691
	692	// get display dimensions
	693	// this will be the dimensions of the front buffer
	694	if (FAILED(hr = mpD3DDevice->GetDisplayMode(0, &dm)))
	695	OGRE_EXCEPT(hr, "Can't get display mode!", "D3D9RenderWindow::writeContentsToFile");
	696
	697	desc.Width = dm.Width;
	698	desc.Height = dm.Height;
	699	desc.Format = D3DFMT_A8R8G8B8;
	700	if (FAILED(hr = mpD3DDevice->CreateOffscreenPlainSurface(
	701	desc.Width,
	702	desc.Height,
	703	desc.Format,
	704	D3DPOOL_SYSTEMMEM,
	705	&pTempSurf,
	706	NULL)))
	707	{
	708	OGRE_EXCEPT(hr, "Cannot create offscreen buffer 1!", "D3D9RenderWindow::writeContentsToFile");
	709	}
	710
	711	if (FAILED(hr = mpD3DDevice->GetFrontBufferData(0, pTempSurf)))
	712	{
	713	SAFE_RELEASE(pTempSurf);
	714	OGRE_EXCEPT(hr, "Can't get front buffer!", "D3D9RenderWindow::writeContentsToFile");
	715	}
	716
	717	D3DLOCKED_RECT lockedRect;
	718	if(mIsFullScreen)
	719	{
	720	if (FAILED(hr = pTempSurf->LockRect(&lockedRect, NULL,
	721	D3DLOCK_READONLY \| D3DLOCK_NOSYSLOCK)))
	722	{
	723	OGRE_EXCEPT(hr, "can't lock rect!", "D3D9RenderWindow::writeContentsToFile");
	724	}
	725	}
	726	else
	727	{
	728	RECT srcRect;
	729	GetWindowRect(mHWnd, &srcRect);
	730
	731	desc.Width = srcRect.right - srcRect.left;
	732	desc.Height = srcRect.bottom - srcRect.top;
	733
	734	if (FAILED(hr = pTempSurf->LockRect(&lockedRect, &srcRect,
	735
	736	D3DLOCK_READONLY \| D3DLOCK_NOSYSLOCK)))
	737	{
	738	OGRE_EXCEPT(hr, "can't lock rect!", "D3D9RenderWindow::writeContentsToFile");
	739	}
	740	}
	741
	742	ImageCodec::ImageData *imgData = new ImageCodec::ImageData();
	743	imgData->width = desc.Width;
	744	imgData->height = desc.Height;
	745	imgData->format = PF_BYTE_RGB;
	746
	747	// Allocate contiguous buffer (surfaces aren't necessarily contiguous)
	748	uchar* pBuffer = new uchar[desc.Width * desc.Height * 3];
	749
	750	uint x, y;
	751	uchar pData, pDest;
	752
	753	pData = (uchar*)lockedRect.pBits;
	754	pDest = pBuffer;
	755	for (y = 0; y < desc.Height; ++y)
	756	{
	757	uchar *pRow = pData;
	758
	759	for (x = 0; x < desc.Width; ++x)
	760	{
	761	switch(desc.Format)
	762	{
	763	case D3DFMT_R5G6B5:
	764	WORD val;
	765
	766	val = ((WORD)pRow);
	767	pRow += 2;
	768
	769	*pDest++ = Bitwise::convertBitPattern((WORD)val, (WORD)0xF800, (BYTE)0xFF);
	770	*pDest++ = Bitwise::convertBitPattern((WORD)val, (WORD)0x07E0, (BYTE)0xFF);
	771	*pDest++ = Bitwise::convertBitPattern((WORD)val, (WORD)0x001F, (BYTE)0xFF);
	772	break;
	773	case D3DFMT_A8R8G8B8:
	774	case D3DFMT_X8R8G8B8:
	775	// Actual format is BRGA for some reason
	776	*pDest++ = pRow[2]; // R
	777	*pDest++ = pRow[1]; // G
	778	*pDest++ = pRow[0]; // B
	779	pRow += 4; // skip alpha / dummy
	780	break;
	781	case D3DFMT_R8G8B8:
	782	// Actual format is BRGA for some reason
	783	*pDest++ = pRow[2]; // R
	784	*pDest++ = pRow[1]; // G
	785	*pDest++ = pRow[0]; // B
	786	pRow += 3;
	787	break;
	788	}
	789
	790
	791	}
	792	// increase by one line
	793	pData += lockedRect.Pitch;
	794	}
	795
	796	// Wrap buffer in a chunk
	797	MemoryDataStreamPtr stream(new MemoryDataStream(pBuffer, desc.Width * desc.Height * 3, false));
	798
	799	// Get codec
	800	size_t pos = filename.find_last_of(".");
	801	String extension;
	802	if( pos == String::npos )
	803	OGRE_EXCEPT(
	804	Exception::ERR_INVALIDPARAMS,
	805	"Unable to determine image type for '" + filename + "' - invalid extension.",
	806	"D3D9RenderWindow::writeContentsToFile" );
	807
	808	while( pos != filename.length() - 1 )
	809	extension += filename[++pos];
	810
	811	// Get the codec
	812	Codec * pCodec = Codec::getCodec(extension);
	813
	814	// Write out
	815	{
	816	Codec::CodecDataPtr ptr(imgData);
	817	pCodec->codeToFile(stream, filename, ptr);
	818	}
	819
	820	delete [] pBuffer;
	821
	822	SAFE_RELEASE(pTempSurf);
	823	SAFE_RELEASE(pSurf);
	824	}
	825	//-----------------------------------------------------------------------------
	826	void D3D9RenderWindow::update(void)
	827	{
	828	D3D9RenderSystem* rs = static_cast<D3D9RenderSystem*>(
	829	Root::getSingleton().getRenderSystem());
	830
	831	// access device through driver
	832	LPDIRECT3DDEVICE9 mpD3DDevice = mDriver->getD3DDevice();
	833
	834	if (rs->isDeviceLost())
	835	{
	836	// Test the cooperative mode first
	837	HRESULT hr = mpD3DDevice->TestCooperativeLevel();
	838	if (hr == D3DERR_DEVICELOST)
	839	{
	840	// device lost, and we can't reset
	841	// can't do anything about it here, wait until we get
	842	// D3DERR_DEVICENOTRESET; rendering calls will silently fail until
	843	// then (except Present, but we ignore device lost there too)
	844	mpRenderSurface = 0;
	845	// need to release if swap chain
	846	if (!mIsSwapChain)
	847	mpRenderZBuffer = 0;
	848	else
	849	SAFE_RELEASE (mpRenderZBuffer);
	850	Sleep(50);
	851	return;
	852	}
	853	else
	854	{
	855	// device lost, and we can reset
	856	rs->restoreLostDevice();
	857
	858	// Still lost?
	859	if (rs->isDeviceLost())
	860	{
	861	// Wait a while
	862	Sleep(50);
	863	return;
	864	}
	865
	866	// fixed: this only works for not swap chained
	867	if (!mIsSwapChain)
	868	{
	869	// re-qeuery buffers
	870	mpD3DDevice->GetRenderTarget( 0, &mpRenderSurface );
	871	mpD3DDevice->GetDepthStencilSurface( &mpRenderZBuffer );
	872	// release immediately so we don't hog them
	873	mpRenderSurface->Release();
	874	mpRenderZBuffer->Release();
	875	}
	876	else
	877	{
	878	mpSwapChain->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &mpRenderSurface );
	879	if (mIsDepthBuffered) {
	880	hr = mpD3DDevice->CreateDepthStencilSurface(
	881	mWidth, mHeight,
	882	md3dpp.AutoDepthStencilFormat,
	883	md3dpp.MultiSampleType,
	884	md3dpp.MultiSampleQuality,
	885	(md3dpp.Flags & D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL),
	886	&mpRenderZBuffer, NULL
	887	);
	888
	889	if (FAILED(hr)) {
	890	OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
	891	"Unable to re-create depth buffer for the swap chain",
	892	"D3D9RenderWindow::update");
	893
	894	}
	895	}
	896	else
	897	{
	898	mpRenderZBuffer = 0;
	899	}
	900
	901	// release immediately so we don't hog them
	902	mpRenderSurface->Release();
	903	}
	904	}
	905
	906	}
	907	RenderWindow::update();
	908	}
	909
	910	#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	911	uchar *D3D9RenderWindow::getBufferContents(int &dimx, int &dimy)
	912	{
	913	HRESULT hr;
	914	LPDIRECT3DSURFACE9 pSurf=NULL, pTempSurf=NULL;
	915	//IDirect3DSurface9 *pTempSurf=NULL;
	916	D3DSURFACE_DESC desc;
	917	D3DDISPLAYMODE dm;
	918
	919	// access device through driver
	920	LPDIRECT3DDEVICE9 mpD3DDevice = mDriver->getD3DDevice();
	921
	922	// get display dimensions
	923	// this will be the dimensions of the front buffer
	924	if (FAILED(hr = mpD3DDevice->GetDisplayMode(0, &dm)))
	925	OGRE_EXCEPT(hr, "Can't get display mode!", "D3D9RenderWindow::getBufferContents");
	926
	927	desc.Width = dm.Width;
	928	desc.Height = dm.Height;
	929	desc.Format = D3DFMT_A8R8G8B8;
	930	if (FAILED(hr = mpD3DDevice->CreateOffscreenPlainSurface(
	931	desc.Width,
	932	desc.Height,
	933	desc.Format,
	934	D3DPOOL_SYSTEMMEM,
	935	&pTempSurf,
	936	NULL)))
	937	{
	938	OGRE_EXCEPT(hr, "Cannot create offscreen buffer 1!", "D3D9RenderWindow::getBufferContents");
	939	}
	940
	941	if (FAILED(hr = mpD3DDevice->GetFrontBufferData(0, pTempSurf)))
	942	//if (FAILED(hr = mpD3DDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pTempSurf)))
	943	{
	944	SAFE_RELEASE(pTempSurf);
	945	OGRE_EXCEPT(hr, "Can't get back buffer!", "D3D9RenderWindow::getBufferContents");
	946	}
	947
	948	if (!mIsFullScreen)
	949	{
	950	POINT pt={0, 0};
	951	RECT srcRect;
	952	GetWindowRect(mHWnd, &srcRect);
	953
	954	desc.Width = srcRect.right - srcRect.left;
	955	desc.Height = srcRect.bottom - srcRect.top;
	956	desc.Format = D3DFMT_A8R8G8B8; // this is what we get from the screen, so stick with it
	957
	958	// NB we can't lock the back buffer direct because it's not created that way
	959	// and to do so hits performance, so copy to another surface
	960	// Must be the same format as the source surface
	961	if (FAILED(hr = mpD3DDevice->CreateOffscreenPlainSurface(
	962	desc.Width,
	963	desc.Height,
	964	desc.Format,
	965	D3DPOOL_DEFAULT,
	966	&pSurf,
	967	NULL)))
	968	{
	969	SAFE_RELEASE(pSurf);
	970	OGRE_EXCEPT(hr, "Cannot create offscreen buffer 2!", "D3D9RenderWindow::getBufferContents");
	971	}
	972
	973	// Copy
	974	if (FAILED(hr = mpD3DDevice->UpdateSurface(pTempSurf, &srcRect, pSurf, &pt)))
	975	{
	976	SAFE_RELEASE(pTempSurf);
	977	SAFE_RELEASE(pSurf);
	978	OGRE_EXCEPT(hr, "Cannot update surface!", "D3D9RenderWindow::getBufferContents");
	979	}
	980
	981	SAFE_RELEASE(pTempSurf);
	982	pTempSurf = pSurf;
	983	pSurf = NULL;
	984	}
	985
	986	D3DLOCKED_RECT lockedRect;
	987	if (FAILED(hr = pTempSurf->LockRect(&lockedRect, NULL,
	988	D3DLOCK_READONLY \| D3DLOCK_NOSYSLOCK)))
	989	{
	990	OGRE_EXCEPT(hr, "can't lock rect!", "D3D9RenderWindow::getBufferContents");
	991	}
	992
	993
	994	dimx = desc.Width;
	995	dimy = desc.Height;
	996
	997	// Allocate contiguous buffer (surfaces aren't necessarily contiguous)
	998	uchar* pBuffer = new uchar[desc.Width * desc.Height * 3];
	999
	1000	uint x, y;
	1001	uchar pData, pDest;
	1002
	1003	pData = (uchar*)lockedRect.pBits;
	1004	pDest = pBuffer;
	1005	for (y = 0; y < desc.Height; ++y)
	1006	{
	1007	uchar *pRow = pData;
	1008
	1009	for (x = 0; x < desc.Width; ++x)
	1010	{
	1011	switch(desc.Format)
	1012	{
	1013	case D3DFMT_R5G6B5:
	1014	WORD val;
	1015
	1016	val = ((WORD)pRow);
	1017	pRow += 2;
	1018
	1019	*pDest++ = Bitwise::convertBitPattern((WORD)val, (WORD)0xF800, (BYTE)0xFF);
	1020	*pDest++ = Bitwise::convertBitPattern((WORD)val, (WORD)0x07E0, (BYTE)0xFF);
	1021	*pDest++ = Bitwise::convertBitPattern((WORD)val, (WORD)0x001F, (BYTE)0xFF);
	1022	break;
	1023	case D3DFMT_A8R8G8B8:
	1024	case D3DFMT_X8R8G8B8:
	1025	// Actual format is BRGA for some reason
	1026	*pDest++ = pRow[2]; // R
	1027	*pDest++ = pRow[1]; // G
	1028	*pDest++ = pRow[0]; // B
	1029	pRow += 4; // skip alpha / dummy
	1030	break;
	1031	case D3DFMT_R8G8B8:
	1032	// Actual format is BRGA for some reason
	1033	*pDest++ = pRow[2]; // R
	1034	*pDest++ = pRow[1]; // G
	1035	*pDest++ = pRow[0]; // B
	1036	pRow += 3;
	1037	break;
	1038	}
	1039
	1040
	1041	}
	1042	// increase by one line
	1043	pData += lockedRect.Pitch;
	1044	}
	1045
	1046	//pTempSurf->UnlockRect();
	1047	SAFE_RELEASE(pTempSurf);
	1048	SAFE_RELEASE(pSurf);
	1049
	1050	return pBuffer;
	1051	}
	1052	#endif // GTP_VISIBILITY_MODIFIED_OGRE
	1053	}

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

Download in other formats: