Context Navigation

OgreD3D9RenderSystem.cpp @ 692

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

Line
1	/*
2	-----------------------------------------------------------------------------
3	This source file is part of OGRE
4	(Object-oriented Graphics Rendering Engine)
5	For the latest info, see http://ogre.sourceforge.net/
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 "OgreD3D9RenderSystem.h"
26	#include "OgreD3D9Prerequisites.h"
27	#include "OgreD3D9DriverList.h"
28	#include "OgreD3D9Driver.h"
29	#include "OgreD3D9VideoModeList.h"
30	#include "OgreD3D9VideoMode.h"
31	#include "OgreD3D9RenderWindow.h"
32	#include "OgreD3D9TextureManager.h"
33	#include "OgreD3D9Texture.h"
34	#include "OgreLogManager.h"
35	#include "OgreLight.h"
36	#include "OgreMath.h"
37	#include "OgreD3D9HardwareBufferManager.h"
38	#include "OgreD3D9HardwareIndexBuffer.h"
39	#include "OgreD3D9HardwareVertexBuffer.h"
40	#include "OgreD3D9VertexDeclaration.h"
41	#include "OgreD3D9GpuProgram.h"
42	#include "OgreD3D9GpuProgramManager.h"
43	//#include "OgreD3D9HLSLProgramFactory.h"
44	#include "OgreHighLevelGpuProgramManager.h"
45	#include "OgreD3D9HardwareOcclusionQuery.h"
46	#include "OgreFrustum.h"
47	#include "OgreD3D9MultiRenderTarget.h"
48
49
50	namespace Ogre
51	{
52
53	//---------------------------------------------------------------------
54	D3D9RenderSystem::D3D9RenderSystem( HINSTANCE hInstance )
55	{
56	OgreGuard( "D3D9RenderSystem::D3D9RenderSystem" );
57	LogManager::getSingleton().logMessage( "D3D9 : " + getName() + " created." );
58
59	// set the instance being passed
60	mhInstance = hInstance;
61
62	// set pointers to NULL
63	mpD3D = NULL;
64	mpD3DDevice = NULL;
65	mDriverList = NULL;
66	mActiveD3DDriver = NULL;
67	mTextureManager = NULL;
68	mHardwareBufferManager = NULL;
69	mGpuProgramManager = NULL;
70	mPrimaryWindow = NULL;
71	mDeviceLost = false;
72	mBasicStatesInitialised = false;
73	mUseNVPerfHUD = false;
74	//mHLSLProgramFactory = NULL;
75
76	// init lights
77	for(int i = 0; i < MAX_LIGHTS; i++ )
78	mLights[i] = 0;
79
80	// Create our Direct3D object
81	if( NULL == (mpD3D = Direct3DCreate9(D3D_SDK_VERSION)) )
82	OGRE_EXCEPT( Exception::ERR_INTERNAL_ERROR, "Failed to create Direct3D9 object", "D3D9RenderSystem::D3D9RenderSystem" );
83
84	// set config options defaults
85	initConfigOptions();
86
87	// fsaa options
88	mFSAAType = D3DMULTISAMPLE_NONE;
89	mFSAAQuality = 0;
90
91	// set stages desc. to defaults
92	for (size_t n = 0; n < OGRE_MAX_TEXTURE_LAYERS; n++)
93	{
94	mTexStageDesc[n].autoTexCoordType = TEXCALC_NONE;
95	mTexStageDesc[n].coordIndex = 0;
96	mTexStageDesc[n].texType = D3D9Mappings::D3D_TEX_TYPE_NORMAL;
97	mTexStageDesc[n].pTex = 0;
98	}
99
100	mLastVertexSourceCount = 0;
101
102	mCurrentLights = 0;
103
104	// Enumerate events
105	mEventNames.push_back("DeviceLost");
106	mEventNames.push_back("DeviceRestored");
107
108
109	OgreUnguard();
110	}
111	//---------------------------------------------------------------------
112	D3D9RenderSystem::~D3D9RenderSystem()
113	{
114	OgreGuard( "D3D9RenderSystem::~D3D9RenderSystem" );
115	shutdown();
116
117
118
119	SAFE_DELETE( mDriverList );
120	SAFE_DELETE( mTextureManager );
121	SAFE_DELETE(mHardwareBufferManager);
122	//SAFE_DELETE(mHLSLProgramFactory);
123	SAFE_DELETE(mGpuProgramManager);
124	SAFE_RELEASE( mpD3D );
125
126	LogManager::getSingleton().logMessage( "D3D9 : " + getName() + " destroyed." );
127	OgreUnguard();
128	}
129	//---------------------------------------------------------------------
130	const String& D3D9RenderSystem::getName() const
131	{
132	static String strName( "Direct3D9 Rendering Subsystem");
133	return strName;
134	}
135	//---------------------------------------------------------------------
136	D3D9DriverList* D3D9RenderSystem::getDirect3DDrivers()
137	{
138	if( !mDriverList )
139	mDriverList = new D3D9DriverList( mpD3D );
140
141	return mDriverList;
142	}
143	//---------------------------------------------------------------------
144	bool D3D9RenderSystem::_checkMultiSampleQuality(D3DMULTISAMPLE_TYPE type, DWORD *outQuality, D3DFORMAT format, UINT adapterNum, D3DDEVTYPE deviceType, BOOL fullScreen)
145	{
146	HRESULT hr;
147	hr = mpD3D->CheckDeviceMultiSampleType(
148	adapterNum,
149	deviceType,
150	format,
151	fullScreen,
152	type,
153	outQuality);
154
155	if (SUCCEEDED(hr))
156	return true;
157	else
158	return false;
159	}
160	//---------------------------------------------------------------------
161	void D3D9RenderSystem::initConfigOptions()
162	{
163	OgreGuard( "D3D9RenderSystem::initConfigOptions" );
164
165	D3D9DriverList* driverList;
166	D3D9Driver* driver;
167
168	ConfigOption optDevice;
169	ConfigOption optVideoMode;
170	ConfigOption optFullScreen;
171	ConfigOption optVSync;
172	ConfigOption optAA;
173	ConfigOption optFPUMode;
174	ConfigOption optNVPerfHUD;
175
176	driverList = this->getDirect3DDrivers();
177
178	optDevice.name = "Rendering Device";
179	optDevice.currentValue = "";
180	optDevice.possibleValues.clear();
181	optDevice.immutable = false;
182
183	optVideoMode.name = "Video Mode";
184	optVideoMode.currentValue = "800 x 600 @ 32-bit colour";
185	optVideoMode.immutable = false;
186
187	optFullScreen.name = "Full Screen";
188	optFullScreen.possibleValues.push_back( "Yes" );
189	optFullScreen.possibleValues.push_back( "No" );
190	optFullScreen.currentValue = "Yes";
191	optFullScreen.immutable = false;
192
193	for( unsigned j=0; j < driverList->count(); j++ )
194	{
195	driver = driverList->item(j);
196	optDevice.possibleValues.push_back( driver->DriverDescription() );
197	// Make first one default
198	if( j==0 )
199	optDevice.currentValue = driver->DriverDescription();
200	}
201
202	optVSync.name = "VSync";
203	optVSync.immutable = false;
204	optVSync.possibleValues.push_back( "Yes" );
205	optVSync.possibleValues.push_back( "No" );
206	optVSync.currentValue = "No";
207
208	optAA.name = "Anti aliasing";
209	optAA.immutable = false;
210	optAA.possibleValues.push_back( "None" );
211	optAA.currentValue = "None";
212
213	optFPUMode.name = "Floating-point mode";
214	#if OGRE_DOUBLE_PRECISION
215	optFPUMode.currentValue = "Consistent";
216	#else
217	optFPUMode.currentValue = "Fastest";
218	#endif
219	optFPUMode.possibleValues.clear();
220	optFPUMode.possibleValues.push_back("Fastest");
221	optFPUMode.possibleValues.push_back("Consistent");
222	optFPUMode.immutable = false;
223
224	optNVPerfHUD.currentValue = "No";
225	optNVPerfHUD.immutable = false;
226	optNVPerfHUD.name = "Allow NVPerfHUD";
227	optNVPerfHUD.possibleValues.push_back( "Yes" );
228	optNVPerfHUD.possibleValues.push_back( "No" );
229
230	mOptions[optDevice.name] = optDevice;
231	mOptions[optVideoMode.name] = optVideoMode;
232	mOptions[optFullScreen.name] = optFullScreen;
233	mOptions[optVSync.name] = optVSync;
234	mOptions[optAA.name] = optAA;
235	mOptions[optFPUMode.name] = optFPUMode;
236	mOptions[optNVPerfHUD.name] = optNVPerfHUD;
237
238	refreshD3DSettings();
239
240	OgreUnguard();
241	}
242	//---------------------------------------------------------------------
243	void D3D9RenderSystem::refreshD3DSettings()
244	{
245	OgreGuard( "D3D9RenderSystem::refreshD3DSettings" );
246
247	ConfigOption* optVideoMode;
248	D3D9Driver* driver = 0;
249	D3D9VideoMode* videoMode;
250
251	ConfigOptionMap::iterator opt = mOptions.find( "Rendering Device" );
252	if( opt != mOptions.end() )
253	{
254	for( unsigned j=0; j < getDirect3DDrivers()->count(); j++ )
255	{
256	driver = getDirect3DDrivers()->item(j);
257	if( driver->DriverDescription() == opt->second.currentValue )
258	break;
259	}
260
261	if (driver)
262	{
263	opt = mOptions.find( "Video Mode" );
264	optVideoMode = &opt->second;
265	optVideoMode->possibleValues.clear();
266	// get vide modes for this device
267	for( unsigned k=0; k < driver->getVideoModeList()->count(); k++ )
268	{
269	videoMode = driver->getVideoModeList()->item( k );
270	optVideoMode->possibleValues.push_back( videoMode->getDescription() );
271	}
272	}
273	}
274
275	OgreUnguard();
276	}
277	//---------------------------------------------------------------------
278	void D3D9RenderSystem::setConfigOption( const String &name, const String &value )
279	{
280	OgreGuard( "D3D9RenderSystem::setConfigOption" );
281
282	StringUtil::StrStreamType str;
283	str << "D3D9 : RenderSystem Option: " << name << " = " << value;
284	LogManager::getSingleton().logMessage(str.str());
285
286	// Find option
287	ConfigOptionMap::iterator it = mOptions.find( name );
288
289	// Update
290	if( it != mOptions.end() )
291	it->second.currentValue = value;
292	else
293	{
294	str.str(StringUtil::BLANK);
295	str << "Option named '" << name << "' does not exist.";
296	OGRE_EXCEPT( Exception::ERR_INVALIDPARAMS, str.str(), "D3D9RenderSystem::setConfigOption" );
297	}
298
299	// Refresh other options if D3DDriver changed
300	if( name == "Rendering Device" )
301	refreshD3DSettings();
302
303	if( name == "Full Screen" )
304	{
305	// Video mode is applicable
306	it = mOptions.find( "Video Mode" );
307	if (it->second.currentValue == "")
308	it->second.currentValue = "800 x 600 @ 32-bit colour";
309	}
310
311	if( name == "Anti aliasing" )
312	{
313	if (value == "None")
314	_setFSAA(D3DMULTISAMPLE_NONE, 0);
315	else
316	{
317	D3DMULTISAMPLE_TYPE fsaa = D3DMULTISAMPLE_NONE;
318	DWORD level = 0;
319
320	if (StringUtil::startsWith(value, "NonMaskable", false))
321	{
322	fsaa = D3DMULTISAMPLE_NONMASKABLE;
323	size_t pos = value.find_last_of(" ");
324	String sNum = value.substr(pos + 1);
325	level = StringConverter::parseInt(sNum);
326	level -= 1;
327	}
328	else if (StringUtil::startsWith(value, "Level", false))
329	{
330	size_t pos = value.find_last_of(" ");
331	String sNum = value.substr(pos + 1);
332	fsaa = (D3DMULTISAMPLE_TYPE)StringConverter::parseInt(sNum);
333	}
334
335	_setFSAA(fsaa, level);
336	}
337	}
338
339	if( name == "VSync" )
340	{
341	if (value == "Yes")
342	mVSync = true;
343	else
344	mVSync = false;
345	}
346
347	if( name == "Allow NVPerfHUD" )
348	{
349	if (value == "Yes")
350	mUseNVPerfHUD = true;
351	else
352	mUseNVPerfHUD = false;
353	}
354
355	if( name == "Video Mode" )
356	{
357	ConfigOption* optFSAA;
358	it = mOptions.find( "Anti aliasing" );
359	optFSAA = &it->second;
360	optFSAA->possibleValues.clear();
361	optFSAA->possibleValues.push_back("None");
362
363	it = mOptions.find("Rendering Device");
364	D3D9Driver *driver = getDirect3DDrivers()->item(it->second.currentValue);
365	if (driver)
366	{
367	it = mOptions.find("Video Mode");
368	D3D9VideoMode *videoMode = driver->getVideoModeList()->item(it->second.currentValue);
369	if (videoMode)
370	{
371	// get non maskable FSAA for this VMODE
372	DWORD numLevels = 0;
373	bool bOK = this->_checkMultiSampleQuality(
374	D3DMULTISAMPLE_NONMASKABLE,
375	&numLevels,
376	videoMode->getFormat(),
377	driver->getAdapterNumber(),
378	D3DDEVTYPE_HAL,
379	TRUE);
380	if (bOK && numLevels > 0)
381	{
382	for (DWORD n = 0; n < numLevels; n++)
383	optFSAA->possibleValues.push_back("NonMaskable " + StringConverter::toString(n + 1));
384	}
385
386	// set maskable levels supported
387	for (unsigned int n = 2; n < 17; n++)
388	{
389	bOK = this->_checkMultiSampleQuality(
390	(D3DMULTISAMPLE_TYPE)n,
391	&numLevels,
392	videoMode->getFormat(),
393	driver->getAdapterNumber(),
394	D3DDEVTYPE_HAL,
395	TRUE);
396	if (bOK)
397	optFSAA->possibleValues.push_back("Level " + StringConverter::toString(n));
398	}
399	}
400	}
401	}
402
403	OgreUnguard();
404	}
405	//---------------------------------------------------------------------
406	String D3D9RenderSystem::validateConfigOptions()
407	{
408	ConfigOptionMap::iterator it;
409
410	// check if video mode is selected
411	it = mOptions.find( "Video Mode" );
412	if( it->second.currentValue == "" )
413	return "A video mode must be selected.";
414
415	it = mOptions.find( "Rendering Device" );
416	bool foundDriver = false;
417	D3D9DriverList* driverList = getDirect3DDrivers();
418	for( ushort j=0; j < driverList->count(); j++ )
419	{
420	if( driverList->item(j)->DriverDescription() == it->second.currentValue )
421	{
422	foundDriver = true;
423	break;
424	}
425	}
426
427	if (!foundDriver)
428	{
429	// Just pick the first driver
430	setConfigOption("Rendering Device", driverList->item(0)->DriverDescription());
431	return "Your DirectX driver name has changed since the last time you ran OGRE; "
432	"the 'Rendering Device' has been changed.";
433	}
434
435	it = mOptions.find( "VSync" );
436	if( it->second.currentValue == "Yes" )
437	mVSync = true;
438	else
439	mVSync = false;
440
441	return "";
442	}
443	//---------------------------------------------------------------------
444	ConfigOptionMap& D3D9RenderSystem::getConfigOptions()
445	{
446	// return a COPY of the current config options
447	return mOptions;
448	}
449	//---------------------------------------------------------------------
450	RenderWindow* D3D9RenderSystem::initialise( bool autoCreateWindow, const String& windowTitle )
451	{
452	RenderWindow* autoWindow = NULL;
453	LogManager::getSingleton().logMessage( "D3D9 : Subsystem Initialising" );
454
455	// Init using current settings
456	mActiveD3DDriver = NULL;
457	ConfigOptionMap::iterator opt = mOptions.find( "Rendering Device" );
458	for( unsigned j=0; j < getDirect3DDrivers()->count(); j++ )
459	{
460	if( getDirect3DDrivers()->item(j)->DriverDescription() == opt->second.currentValue )
461	{
462	mActiveD3DDriver = getDirect3DDrivers()->item(j);
463	break;
464	}
465	}
466
467	if( !mActiveD3DDriver )
468	OGRE_EXCEPT( Exception::ERR_INVALIDPARAMS, "Problems finding requested Direct3D driver!", "D3D9RenderSystem::initialise" );
469
470	if( autoCreateWindow )
471	{
472	bool fullScreen;
473	opt = mOptions.find( "Full Screen" );
474	if( opt == mOptions.end() )
475	Exception( Exception::ERR_INTERNAL_ERROR, "Can't find full screen option!", "D3D9RenderSystem::initialise" );
476	fullScreen = opt->second.currentValue == "Yes";
477
478	D3D9VideoMode* videoMode = NULL;
479	unsigned int width, height;
480	String temp;
481
482	opt = mOptions.find( "Video Mode" );
483	if( opt == mOptions.end() )
484	Exception( Exception::ERR_INTERNAL_ERROR, "Can't find Video Mode option!", "D3D9RenderSystem::initialise" );
485
486	for( unsigned j=0; j < mActiveD3DDriver->getVideoModeList()->count(); j++ )
487	{
488	temp = mActiveD3DDriver->getVideoModeList()->item(j)->getDescription();
489	if( temp == opt->second.currentValue )
490	{
491	videoMode = mActiveD3DDriver->getVideoModeList()->item(j);
492	break;
493	}
494	}
495
496	if( !videoMode )
497	OGRE_EXCEPT( Exception::ERR_INTERNAL_ERROR, "Can't find requested video mode.", "D3D9RenderSystem::initialise" );
498
499	width = videoMode->getWidth();
500	height = videoMode->getHeight();
501
502	NameValuePairList miscParams;
503	miscParams["colourDepth"] = StringConverter::toString(videoMode->getColourDepth());
504	miscParams["FSAA"] = StringConverter::toString(mFSAAType);
505	miscParams["FSAAQuality"] = StringConverter::toString(mFSAAQuality);
506	miscParams["vsync"] = StringConverter::toString(mVSync);
507	miscParams["useNVPerfHUD"] = StringConverter::toString(mUseNVPerfHUD);
508
509	autoWindow = this->createRenderWindow( windowTitle, width, height,
510	fullScreen, &miscParams );
511
512	// If we have 16bit depth buffer enable w-buffering.
513	assert( autoWindow );
514	if ( autoWindow->getColourDepth() == 16 )
515	{
516	mWBuffer = true;
517	}
518	else
519	{
520	mWBuffer = false;
521	}
522	}
523
524	LogManager::getSingleton().logMessage("***************************************");
525
526	LogManager::getSingleton().logMessage("* D3D9 : Subsystem Initialised OK *");
527	LogManager::getSingleton().logMessage("***************************************");
528
529	// call superclass method
530	RenderSystem::initialise( autoCreateWindow );
531
532
533	return autoWindow;
534	}
535	//---------------------------------------------------------------------
536	void D3D9RenderSystem::_setFSAA(D3DMULTISAMPLE_TYPE type, DWORD qualityLevel)
537	{
538	if (!mpD3DDevice)
539	{
540	mFSAAType = type;
541	mFSAAQuality = qualityLevel;
542	}
543	}
544	//---------------------------------------------------------------------
545	void D3D9RenderSystem::reinitialise()
546	{
547	LogManager::getSingleton().logMessage( "D3D9 : Reinitialising" );
548	this->shutdown();
549	this->initialise( true );
550	}
551	//---------------------------------------------------------------------
552	void D3D9RenderSystem::shutdown()
553	{
554	RenderSystem::shutdown();
555	freeDevice();
556	SAFE_DELETE( mDriverList );
557	mActiveD3DDriver = NULL;
558	mpD3DDevice = NULL;
559	mBasicStatesInitialised = false;
560	LogManager::getSingleton().logMessage("D3D9 : Shutting down cleanly.");
561	}
562	//---------------------------------------------------------------------
563	RenderWindow* D3D9RenderSystem::createRenderWindow(const String &name,
564	unsigned int width, unsigned int height, bool fullScreen,
565	const NameValuePairList *miscParams)
566	{
567
568	OgreGuard( "D3D9RenderSystem::createRenderWindow" );
569
570	// Check we're not creating a secondary window when the primary
571	// was fullscreen
572	if (mPrimaryWindow && mPrimaryWindow->isFullScreen())
573	{
574	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
575	"Cannot create secondary windows when the primary is full screen",
576	"D3D9RenderSystem::createRenderWindow");
577	}
578	if (mPrimaryWindow && fullScreen)
579	{
580	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
581	"Cannot create full screen secondary windows",
582	"D3D9RenderSystem::createRenderWindow");
583	}
584
585	// Log a message
586	std::stringstream ss;
587	ss << "D3D9RenderSystem::createRenderWindow \"" << name << "\", " <<
588	width << "x" << height << " ";
589	if(fullScreen)
590	ss << "fullscreen ";
591	else
592	ss << "windowed ";
593	if(miscParams)
594	{
595	ss << " miscParams: ";
596	NameValuePairList::const_iterator it;
597	for(it=miscParams->begin(); it!=miscParams->end(); ++it)
598	{
599	ss << it->first << "=" << it->second << " ";
600	}
601	LogManager::getSingleton().logMessage(ss.str());
602	}
603
604	String msg;
605
606	// Make sure we don't already have a render target of the
607	// sam name as the one supplied
608	if( mRenderTargets.find( name ) != mRenderTargets.end() )
609	{
610	msg = "A render target of the same name '" + name + "' already "
611	"exists. You cannot create a new window with this name.";
612	OGRE_EXCEPT( Exception::ERR_INTERNAL_ERROR, msg, "D3D9RenderSystem::createRenderWindow" );
613	}
614
615	RenderWindow* win = new D3D9RenderWindow(mhInstance, mActiveD3DDriver,
616	mPrimaryWindow ? mpD3DDevice : 0);
617
618	win->create( name, width, height, fullScreen, miscParams);
619
620	attachRenderTarget( *win );
621
622	// If this is the first window, get the D3D device and create the texture manager
623	if( !mPrimaryWindow )
624	{
625	mPrimaryWindow = (D3D9RenderWindow *)win;
626	win->getCustomAttribute( "D3DDEVICE", &mpD3DDevice );
627
628	// Create the texture manager for use by others
629	mTextureManager = new D3D9TextureManager( mpD3DDevice );
630	// Also create hardware buffer manager
631	mHardwareBufferManager = new D3D9HardwareBufferManager(mpD3DDevice);
632
633	// Create the GPU program manager
634	mGpuProgramManager = new D3D9GpuProgramManager(mpD3DDevice);
635	// create & register HLSL factory
636	//mHLSLProgramFactory = new D3D9HLSLProgramFactory();
637	//HighLevelGpuProgramManager::getSingleton().addFactory(mHLSLProgramFactory);
638	mGpuProgramManager->_pushSyntaxCode("hlsl");
639
640
641	// Initialise the capabilities structures
642	initCapabilities();
643
644	}
645	else
646	{
647	mSecondaryWindows.push_back(static_cast<D3D9RenderWindow *>(win));
648	}
649
650	OgreUnguardRet( win );
651	}
652	//---------------------------------------------------------------------
653	void D3D9RenderSystem::initCapabilities(void)
654	{
655	// get caps
656	mpD3DDevice->GetDeviceCaps( &mCaps );
657
658	// Check for hardware stencil support
659	LPDIRECT3DSURFACE9 pSurf;
660	D3DSURFACE_DESC surfDesc;
661	mpD3DDevice->GetDepthStencilSurface(&pSurf);
662	pSurf->GetDesc(&surfDesc);
663	pSurf->Release();
664
665	if (surfDesc.Format == D3DFMT_D24S8 \|\| surfDesc.Format == D3DFMT_D24X8)
666	{
667	mCapabilities->setCapability(RSC_HWSTENCIL);
668	// Actually, it's always 8-bit
669	mCapabilities->setStencilBufferBitDepth(8);
670
671	}
672
673	// Set number of texture units
674	mCapabilities->setNumTextureUnits(mCaps.MaxSimultaneousTextures);
675	// Anisotropy?
676	if (mCaps.MaxAnisotropy > 1)
677	mCapabilities->setCapability(RSC_ANISOTROPY);
678	// Automatic mipmap generation?
679	if (mCaps.Caps2 & D3DCAPS2_CANAUTOGENMIPMAP)
680	mCapabilities->setCapability(RSC_AUTOMIPMAP);
681	// Blending between stages supported
682	mCapabilities->setCapability(RSC_BLENDING);
683	// Dot 3
684	if (mCaps.TextureOpCaps & D3DTEXOPCAPS_DOTPRODUCT3)
685	mCapabilities->setCapability(RSC_DOT3);
686	// Cube map
687	if (mCaps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP)
688	mCapabilities->setCapability(RSC_CUBEMAPPING);
689
690	// We always support compression, D3DX will decompress if device does not support
691	mCapabilities->setCapability(RSC_TEXTURE_COMPRESSION);
692	mCapabilities->setCapability(RSC_TEXTURE_COMPRESSION_DXT);
693
694	// We always support VBOs
695	mCapabilities->setCapability(RSC_VBO);
696
697	// Scissor test
698	if (mCaps.RasterCaps & D3DPRASTERCAPS_SCISSORTEST)
699	mCapabilities->setCapability(RSC_SCISSOR_TEST);
700
701	// Two-sided stencil
702	if (mCaps.StencilCaps & D3DSTENCILCAPS_TWOSIDED)
703	mCapabilities->setCapability(RSC_TWO_SIDED_STENCIL);
704
705	// stencil wrap
706	if ((mCaps.StencilCaps & D3DSTENCILCAPS_INCR) &&
707	(mCaps.StencilCaps & D3DSTENCILCAPS_DECR))
708	mCapabilities->setCapability(RSC_STENCIL_WRAP);
709
710	// Check for hardware occlusion support
711	if ( ( mpD3DDevice->CreateQuery(D3DQUERYTYPE_OCCLUSION, NULL ) ) == D3D_OK )
712	{
713	mCapabilities->setCapability(RSC_HWOCCLUSION);
714	}
715	convertVertexShaderCaps();
716	convertPixelShaderCaps();
717
718	// User clip planes
719	if (mCaps.MaxUserClipPlanes > 0)
720	{
721	mCapabilities->setCapability(RSC_USER_CLIP_PLANES);
722	}
723
724	// UBYTE4 type?
725	if (mCaps.DeclTypes & D3DDTCAPS_UBYTE4)
726	{
727	mCapabilities->setCapability(RSC_VERTEX_FORMAT_UBYTE4);
728	}
729
730	// Infinite projection?
731	// We have no capability for this, so we have to base this on our
732	// experience and reports from users
733	// Non-vertex program capable hardware does not appear to support it
734	if (mCapabilities->hasCapability(RSC_VERTEX_PROGRAM))
735	{
736	// GeForce4 Ti (and presumably GeForce3) does not
737	// render infinite projection properly, even though it does in GL
738	// So exclude all cards prior to the FX range from doing infinite
739	const D3DADAPTER_IDENTIFIER9& adapterID = mActiveD3DDriver->getAdapterIdentifier();
740	if (adapterID.VendorId != 0x10DE \|\| // not nVidia
741	!((adapterID.DeviceId >= 0x200 && adapterID.DeviceId <= 0x20F) \|\| //gf3
742	(adapterID.DeviceId >= 0x250 && adapterID.DeviceId <= 0x25F) \|\| //gf4ti
743	(adapterID.DeviceId >= 0x280 && adapterID.DeviceId <= 0x28F) \|\| //gf4ti
744	(adapterID.DeviceId >= 0x170 && adapterID.DeviceId <= 0x18F) \|\| //gf4 go
745	(adapterID.DeviceId >= 0x280 && adapterID.DeviceId <= 0x28F))) //gf4ti go
746	{
747	mCapabilities->setCapability(RSC_INFINITE_FAR_PLANE);
748	}
749
750	}
751
752	// 3D textures?
753	if (mCaps.TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP)
754	{
755	mCapabilities->setCapability(RSC_TEXTURE_3D);
756	}
757
758	// non-power-of-two texturs always supported
759	mCapabilities->setCapability(RSC_NON_POWER_OF_2_TEXTURES);
760
761	// We always support rendertextures bigger than the frame buffer
762	mCapabilities->setCapability(RSC_HWRENDER_TO_TEXTURE);
763
764	// Determine if any floating point texture format is supported
765	D3DFORMAT floatFormats[6] = {D3DFMT_R16F, D3DFMT_G16R16F,
766	D3DFMT_A16B16G16R16F, D3DFMT_R32F, D3DFMT_G32R32F,
767	D3DFMT_A32B32G32R32F};
768	LPDIRECT3DSURFACE9 bbSurf;
769	mPrimaryWindow->getCustomAttribute("DDBACKBUFFER", &bbSurf);
770	D3DSURFACE_DESC bbSurfDesc;
771	bbSurf->GetDesc(&bbSurfDesc);
772
773	for (int i = 0; i < 6; ++i)
774	{
775	if (SUCCEEDED(mpD3D->CheckDeviceFormat(D3DADAPTER_DEFAULT,
776	D3DDEVTYPE_HAL, bbSurfDesc.Format,
777	0, D3DRTYPE_TEXTURE, floatFormats[i])))
778	{
779	mCapabilities->setCapability(RSC_TEXTURE_FLOAT);
780	break;
781	}
782
783	}
784
785	// Number of render targets
786	mCapabilities->setNumMultiRenderTargets(std::min((ushort)mCaps.NumSimultaneousRTs, (ushort)OGRE_MAX_MULTIPLE_RENDER_TARGETS));
787
788	//
789	if(mCaps.PrimitiveMiscCaps & D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS)
790	{
791	LogManager::getSingleton().logMessage("Multiple render targets with independent bit depths supported");
792	}
793
794	// Point size
795	mCapabilities->setMaxPointSize(mCaps.MaxPointSize);
796
797
798	Log* defaultLog = LogManager::getSingleton().getDefaultLog();
799	if (defaultLog)
800	{
801	mCapabilities->log(defaultLog);
802	}
803	}
804	//---------------------------------------------------------------------
805	void D3D9RenderSystem::convertVertexShaderCaps(void)
806	{
807	ushort major, minor;
808	major = static_cast<ushort>((mCaps.VertexShaderVersion & 0x0000FF00) >> 8);
809	minor = static_cast<ushort>(mCaps.VertexShaderVersion & 0x000000FF);
810
811	bool vs2x = false;
812	bool vs2a = false;
813
814	// Special case detection for vs_2_x/a support
815	if (major >= 2)
816	{
817	if ((mCaps.VS20Caps.Caps & D3DVS20CAPS_PREDICATION) &&
818	(mCaps.VS20Caps.DynamicFlowControlDepth > 0) &&
819	(mCaps.VS20Caps.NumTemps >= 12))
820	{
821	vs2x = true;
822	}
823
824	if ((mCaps.VS20Caps.Caps & D3DVS20CAPS_PREDICATION) &&
825	(mCaps.VS20Caps.DynamicFlowControlDepth > 0) &&
826	(mCaps.VS20Caps.NumTemps >= 13))
827	{
828	vs2a = true;
829	}
830	}
831
832	// Populate max version & params
833	switch (major)
834	{
835	case 1:
836	mCapabilities->setMaxVertexProgramVersion("vs_1_1");
837	// No boolean params allowed
838	mCapabilities->setVertexProgramConstantBoolCount(0);
839	// No integer params allowed
840	mCapabilities->setVertexProgramConstantIntCount(0);
841	// float params, always 4D
842	mCapabilities->setVertexProgramConstantFloatCount(mCaps.MaxVertexShaderConst);
843
844	break;
845	case 2:
846	if (vs2a)
847	{
848	mCapabilities->setMaxVertexProgramVersion("vs_2_a");
849	}
850	else if (vs2x)
851	{
852	mCapabilities->setMaxVertexProgramVersion("vs_2_x");
853	}
854	else
855	{
856	mCapabilities->setMaxVertexProgramVersion("vs_2_0");
857	}
858	// 16 boolean params allowed
859	mCapabilities->setVertexProgramConstantBoolCount(16);
860	// 16 integer params allowed, 4D
861	mCapabilities->setVertexProgramConstantIntCount(16);
862	// float params, always 4D
863	mCapabilities->setVertexProgramConstantFloatCount(mCaps.MaxVertexShaderConst);
864	break;
865	case 3:
866	mCapabilities->setMaxVertexProgramVersion("vs_3_0");
867	// 16 boolean params allowed
868	mCapabilities->setVertexProgramConstantBoolCount(16);
869	// 16 integer params allowed, 4D
870	mCapabilities->setVertexProgramConstantIntCount(16);
871	// float params, always 4D
872	mCapabilities->setVertexProgramConstantFloatCount(mCaps.MaxVertexShaderConst);
873	break;
874	default:
875	mCapabilities->setMaxVertexProgramVersion("");
876	break;
877	}
878
879	// populate syntax codes in program manager (no breaks in this one so it falls through)
880	switch(major)
881	{
882	case 3:
883	mGpuProgramManager->_pushSyntaxCode("vs_3_0");
884	case 2:
885	if (vs2x)
886	mGpuProgramManager->_pushSyntaxCode("vs_2_x");
887	if (vs2a)
888	mGpuProgramManager->_pushSyntaxCode("vs_2_a");
889
890	mGpuProgramManager->_pushSyntaxCode("vs_2_0");
891	case 1:
892	mGpuProgramManager->_pushSyntaxCode("vs_1_1");
893	mCapabilities->setCapability(RSC_VERTEX_PROGRAM);
894	}
895	}
896	//---------------------------------------------------------------------
897	void D3D9RenderSystem::convertPixelShaderCaps(void)
898	{
899	ushort major, minor;
900	major = static_cast<ushort>((mCaps.PixelShaderVersion & 0x0000FF00) >> 8);
901	minor = static_cast<ushort>(mCaps.PixelShaderVersion & 0x000000FF);
902
903	bool ps2a = false;
904	bool ps2b = false;
905	bool ps2x = false;
906
907	// Special case detection for ps_2_x/a/b support
908	if (major >= 2)
909	{
910	if ((mCaps.PS20Caps.Caps & D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT) &&
911	(mCaps.PS20Caps.NumTemps >= 32))
912	{
913	ps2b = true;
914	}
915
916	if ((mCaps.PS20Caps.Caps & D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT) &&
917	(mCaps.PS20Caps.Caps & D3DPS20CAPS_NODEPENDENTREADLIMIT) &&
918	(mCaps.PS20Caps.Caps & D3DPS20CAPS_ARBITRARYSWIZZLE) &&
919	(mCaps.PS20Caps.Caps & D3DPS20CAPS_GRADIENTINSTRUCTIONS) &&
920	(mCaps.PS20Caps.Caps & D3DPS20CAPS_PREDICATION) &&
921	(mCaps.PS20Caps.NumTemps >= 22))
922	{
923	ps2a = true;
924	}
925
926	// Does this enough?
927	if (ps2a \|\| ps2b)
928	{
929	ps2x = true;
930	}
931	}
932
933	switch (major)
934	{
935	case 1:
936	switch(minor)
937	{
938	case 1:
939	mCapabilities->setMaxFragmentProgramVersion("ps_1_1");
940	break;
941	case 2:
942	mCapabilities->setMaxFragmentProgramVersion("ps_1_2");
943	break;
944	case 3:
945	mCapabilities->setMaxFragmentProgramVersion("ps_1_3");
946	break;
947	case 4:
948	mCapabilities->setMaxFragmentProgramVersion("ps_1_4");
949	break;
950	}
951	// no boolean params allowed
952	mCapabilities->setFragmentProgramConstantBoolCount(0);
953	// no integer params allowed
954	mCapabilities->setFragmentProgramConstantIntCount(0);
955	// float params, always 4D
956	// NB in ps_1_x these are actually stored as fixed point values,
957	// but they are entered as floats
958	mCapabilities->setFragmentProgramConstantFloatCount(8);
959	break;
960	case 2:
961	if (ps2a)
962	{
963	mCapabilities->setMaxFragmentProgramVersion("ps_2_a");
964	}
965	else if (ps2b)
966	{
967	mCapabilities->setMaxFragmentProgramVersion("ps_2_b");
968	}
969	else if (ps2x)
970	{
971	mCapabilities->setMaxFragmentProgramVersion("ps_2_x");
972	}
973	else
974	{
975	mCapabilities->setMaxFragmentProgramVersion("ps_2_0");
976	}
977	// 16 boolean params allowed
978	mCapabilities->setFragmentProgramConstantBoolCount(16);
979	// 16 integer params allowed, 4D
980	mCapabilities->setFragmentProgramConstantIntCount(16);
981	// float params, always 4D
982	mCapabilities->setFragmentProgramConstantFloatCount(32);
983	break;
984	case 3:
985	if (minor > 0)
986	{
987	mCapabilities->setMaxFragmentProgramVersion("ps_3_x");
988	}
989	else
990	{
991	mCapabilities->setMaxFragmentProgramVersion("ps_3_0");
992	}
993	// 16 boolean params allowed
994	mCapabilities->setFragmentProgramConstantBoolCount(16);
995	// 16 integer params allowed, 4D
996	mCapabilities->setFragmentProgramConstantIntCount(16);
997	// float params, always 4D
998	mCapabilities->setFragmentProgramConstantFloatCount(224);
999	break;
1000	default:
1001	mCapabilities->setMaxFragmentProgramVersion("");
1002	break;
1003	}
1004
1005	// populate syntax codes in program manager (no breaks in this one so it falls through)
1006	switch(major)
1007	{
1008	case 3:
1009	if (minor > 0)
1010	mGpuProgramManager->_pushSyntaxCode("ps_3_x");
1011
1012	mGpuProgramManager->_pushSyntaxCode("ps_3_0");
1013	case 2:
1014	if (ps2x)
1015	mGpuProgramManager->_pushSyntaxCode("ps_2_x");
1016	if (ps2a)
1017	mGpuProgramManager->_pushSyntaxCode("ps_2_a");
1018	if (ps2b)
1019	mGpuProgramManager->_pushSyntaxCode("ps_2_b");
1020
1021	mGpuProgramManager->_pushSyntaxCode("ps_2_0");
1022	case 1:
1023	if (major > 1 \|\| minor >= 4)
1024	mGpuProgramManager->_pushSyntaxCode("ps_1_4");
1025	if (major > 1 \|\| minor >= 3)
1026	mGpuProgramManager->_pushSyntaxCode("ps_1_3");
1027	if (major > 1 \|\| minor >= 2)
1028	mGpuProgramManager->_pushSyntaxCode("ps_1_2");
1029
1030	mGpuProgramManager->_pushSyntaxCode("ps_1_1");
1031	mCapabilities->setCapability(RSC_FRAGMENT_PROGRAM);
1032	}
1033	}
1034	//-----------------------------------------------------------------------
1035	MultiRenderTarget * D3D9RenderSystem::createMultiRenderTarget(const String & name)
1036	{
1037	MultiRenderTarget *retval;
1038	retval = new D3D9MultiRenderTarget(name);
1039	attachRenderTarget(*retval);
1040
1041	return retval;
1042	}
1043	//---------------------------------------------------------------------
1044	void D3D9RenderSystem::destroyRenderTarget(const String& name)
1045	{
1046	// Check in specialised lists
1047	if (mPrimaryWindow->getName() == name)
1048	{
1049	// We're destroying the primary window, so reset device and window
1050	mPrimaryWindow = 0;
1051	}
1052	else
1053	{
1054	// Check secondary windows
1055	SecondaryWindowList::iterator sw;
1056	for (sw = mSecondaryWindows.begin(); sw != mSecondaryWindows.end(); ++sw)
1057	{
1058	if ((*sw)->getName() == name)
1059	{
1060	mSecondaryWindows.erase(sw);
1061	break;
1062	}
1063	}
1064	}
1065	// Do the real removal
1066	RenderSystem::destroyRenderTarget(name);
1067
1068	// Did we destroy the primary?
1069	if (!mPrimaryWindow)
1070	{
1071	// device is no longer valid, so free it all up
1072	freeDevice();
1073	}
1074
1075	}
1076	//-----------------------------------------------------------------------
1077	void D3D9RenderSystem::freeDevice(void)
1078	{
1079	if (mpD3DDevice)
1080	{
1081	// Set all texture units to nothing to release texture surfaces
1082	_disableTextureUnitsFrom(0);
1083	// Unbind any vertex streams to avoid memory leaks
1084	for (unsigned int i = 0; i < mLastVertexSourceCount; ++i)
1085	{
1086	HRESULT hr = mpD3DDevice->SetStreamSource(i, NULL, 0, 0);
1087	}
1088	// Clean up depth stencil surfaces
1089	_cleanupDepthStencils();
1090	SAFE_RELEASE(mpD3DDevice);
1091	mActiveD3DDriver->setD3DDevice(NULL);
1092	mpD3DDevice = 0;
1093
1094	}
1095
1096
1097	}
1098	//---------------------------------------------------------------------
1099	String D3D9RenderSystem::getErrorDescription( long errorNumber ) const
1100	{
1101	const String errMsg = DXGetErrorDescription9( errorNumber );
1102	return errMsg;
1103	}
1104	//---------------------------------------------------------------------
1105	VertexElementType D3D9RenderSystem::getColourVertexElementType(void) const
1106	{
1107	return VET_COLOUR_ARGB;
1108	}
1109	//---------------------------------------------------------------------
1110	void D3D9RenderSystem::_convertProjectionMatrix(const Matrix4& matrix,
1111	Matrix4& dest, bool forGpuProgram)
1112	{
1113	dest = matrix;
1114
1115	// Convert depth range from [-1,+1] to [0,1]
1116	dest[2][0] = (dest[2][0] + dest[3][0]) / 2;
1117	dest[2][1] = (dest[2][1] + dest[3][1]) / 2;
1118	dest[2][2] = (dest[2][2] + dest[3][2]) / 2;
1119	dest[2][3] = (dest[2][3] + dest[3][3]) / 2;
1120
1121	if (!forGpuProgram)
1122	{
1123	// Convert right-handed to left-handed
1124	dest[0][2] = -dest[0][2];
1125	dest[1][2] = -dest[1][2];
1126	dest[2][2] = -dest[2][2];
1127	dest[3][2] = -dest[3][2];
1128	}
1129	}
1130	//---------------------------------------------------------------------
1131	void D3D9RenderSystem::_makeProjectionMatrix(const Radian& fovy, Real aspect, Real nearPlane,
1132	Real farPlane, Matrix4& dest, bool forGpuProgram)
1133	{
1134	Radian theta ( fovy * 0.5 );
1135	Real h = 1 / Math::Tan(theta);
1136	Real w = h / aspect;
1137	Real q, qn;
1138	if (farPlane == 0)
1139	{
1140	q = 1 - Frustum::INFINITE_FAR_PLANE_ADJUST;
1141	qn = nearPlane * (Frustum::INFINITE_FAR_PLANE_ADJUST - 1);
1142	}
1143	else
1144	{
1145	q = farPlane / ( farPlane - nearPlane );
1146	qn = -q * nearPlane;
1147	}
1148
1149	dest = Matrix4::ZERO;
1150	dest[0][0] = w;
1151	dest[1][1] = h;
1152
1153	if (forGpuProgram)
1154	{
1155	dest[2][2] = -q;
1156	dest[3][2] = -1.0f;
1157	}
1158	else
1159	{
1160	dest[2][2] = q;
1161	dest[3][2] = 1.0f;
1162	}
1163
1164	dest[2][3] = qn;
1165	}
1166	//---------------------------------------------------------------------
1167	void D3D9RenderSystem::_makeOrthoMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
1168	Matrix4& dest, bool forGpuProgram )
1169	{
1170	Radian thetaY (fovy / 2.0f);
1171	Real tanThetaY = Math::Tan(thetaY);
1172
1173	//Real thetaX = thetaY * aspect;
1174	Real tanThetaX = tanThetaY * aspect; //Math::Tan(thetaX);
1175	Real half_w = tanThetaX * nearPlane;
1176	Real half_h = tanThetaY * nearPlane;
1177	Real iw = 1.0 / half_w;
1178	Real ih = 1.0 / half_h;
1179	Real q;
1180	if (farPlane == 0)
1181	{
1182	q = 0;
1183	}
1184	else
1185	{
1186	q = 1.0 / (farPlane - nearPlane);
1187	}
1188
1189	dest = Matrix4::ZERO;
1190	dest[0][0] = iw;
1191	dest[1][1] = ih;
1192	dest[2][2] = q;
1193	dest[2][3] = -nearPlane / (farPlane - nearPlane);
1194	dest[3][3] = 1;
1195
1196	if (forGpuProgram)
1197	{
1198	dest[2][2] = -dest[2][2];
1199	}
1200	}
1201	//---------------------------------------------------------------------
1202	void D3D9RenderSystem::setAmbientLight( float r, float g, float b )
1203	{
1204	HRESULT hr = __SetRenderState( D3DRS_AMBIENT, D3DCOLOR_COLORVALUE( r, g, b, 1.0f ) );
1205	if( FAILED( hr ) )
1206	OGRE_EXCEPT( hr, "Failed to set render stat D3DRS_AMBIENT", "D3D9RenderSystem::setAmbientLight" );
1207	}
1208	//---------------------------------------------------------------------
1209	void D3D9RenderSystem::_useLights(const LightList& lights, unsigned short limit)
1210	{
1211	LightList::const_iterator i, iend;
1212	iend = lights.end();
1213	unsigned short num = 0;
1214	for (i = lights.begin(); i != iend && num < limit; ++i, ++num)
1215	{
1216	setD3D9Light(num, *i);
1217	}
1218	// Disable extra lights
1219	for (; num < mCurrentLights; ++num)
1220	{
1221	setD3D9Light(num, NULL);
1222	}
1223	mCurrentLights = std::min(limit, static_cast<unsigned short>(lights.size()));
1224
1225	}
1226	//---------------------------------------------------------------------
1227	void D3D9RenderSystem::setShadingType( ShadeOptions so )
1228	{
1229	HRESULT hr = __SetRenderState( D3DRS_SHADEMODE, D3D9Mappings::get(so) );
1230	if( FAILED( hr ) )
1231	OGRE_EXCEPT( hr, "Failed to set render stat D3DRS_SHADEMODE", "D3D9RenderSystem::setShadingType" );
1232	}
1233	//---------------------------------------------------------------------
1234	void D3D9RenderSystem::setLightingEnabled( bool enabled )
1235	{
1236	HRESULT hr;
1237	if( FAILED( hr = __SetRenderState( D3DRS_LIGHTING, enabled ) ) )
1238	OGRE_EXCEPT( hr, "Failed to set render state D3DRS_LIGHTING", "D3D9RenderSystem::setLightingEnabled" );
1239	}
1240	//---------------------------------------------------------------------
1241	void D3D9RenderSystem::setD3D9Light( size_t index, Light* lt )
1242	{
1243	HRESULT hr;
1244
1245	D3DLIGHT9 d3dLight;
1246	ZeroMemory( &d3dLight, sizeof(d3dLight) );
1247
1248	if (!lt)
1249	{
1250	if( FAILED( hr = mpD3DDevice->LightEnable( index, FALSE) ) )
1251	OGRE_EXCEPT( hr, "Unable to disable light", "D3D9RenderSystem::setD3D9Light" );
1252	}
1253	else
1254	{
1255	switch( lt->getType() )
1256	{
1257	case Light::LT_POINT:
1258	d3dLight.Type = D3DLIGHT_POINT;
1259	break;
1260
1261	case Light::LT_DIRECTIONAL:
1262	d3dLight.Type = D3DLIGHT_DIRECTIONAL;
1263	break;
1264
1265	case Light::LT_SPOTLIGHT:
1266	d3dLight.Type = D3DLIGHT_SPOT;
1267	d3dLight.Falloff = lt->getSpotlightFalloff();
1268	d3dLight.Theta = lt->getSpotlightInnerAngle().valueRadians();
1269	d3dLight.Phi = lt->getSpotlightOuterAngle().valueRadians();
1270	break;
1271	}
1272
1273	ColourValue col;
1274	col = lt->getDiffuseColour();
1275	d3dLight.Diffuse = D3DXCOLOR( col.r, col.g, col.b, col.a );
1276
1277	col = lt->getSpecularColour();
1278	d3dLight.Specular = D3DXCOLOR( col.r, col.g, col.b, col.a );
1279
1280	Vector3 vec;
1281	if( lt->getType() != Light::LT_DIRECTIONAL )
1282	{
1283	vec = lt->getDerivedPosition();
1284	d3dLight.Position = D3DXVECTOR3( vec.x, vec.y, vec.z );
1285	}
1286	if( lt->getType() != Light::LT_POINT )
1287	{
1288	vec = lt->getDerivedDirection();
1289	d3dLight.Direction = D3DXVECTOR3( vec.x, vec.y, vec.z );
1290	}
1291
1292	d3dLight.Range = lt->getAttenuationRange();
1293	d3dLight.Attenuation0 = lt->getAttenuationConstant();
1294	d3dLight.Attenuation1 = lt->getAttenuationLinear();
1295	d3dLight.Attenuation2 = lt->getAttenuationQuadric();
1296
1297	if( FAILED( hr = mpD3DDevice->SetLight( index, &d3dLight ) ) )
1298	OGRE_EXCEPT( hr, "Unable to set light details", "D3D9RenderSystem::setD3D9Light" );
1299
1300	if( FAILED( hr = mpD3DDevice->LightEnable( index, TRUE ) ) )
1301	OGRE_EXCEPT( hr, "Unable to enable light", "D3D9RenderSystem::setD3D9Light" );
1302	}
1303
1304
1305	}
1306	//---------------------------------------------------------------------
1307	void D3D9RenderSystem::_setViewMatrix( const Matrix4 &m )
1308	{
1309	// save latest view matrix
1310	mViewMatrix = m;
1311	mViewMatrix[2][0] = -mViewMatrix[2][0];
1312	mViewMatrix[2][1] = -mViewMatrix[2][1];
1313	mViewMatrix[2][2] = -mViewMatrix[2][2];
1314	mViewMatrix[2][3] = -mViewMatrix[2][3];
1315
1316	D3DXMATRIX d3dmat = D3D9Mappings::makeD3DXMatrix( mViewMatrix );
1317
1318	HRESULT hr;
1319	if( FAILED( hr = mpD3DDevice->SetTransform( D3DTS_VIEW, &d3dmat ) ) )
1320	OGRE_EXCEPT( hr, "Cannot set D3D9 view matrix", "D3D9RenderSystem::_setViewMatrix" );
1321	}
1322	//---------------------------------------------------------------------
1323	void D3D9RenderSystem::_setProjectionMatrix( const Matrix4 &m )
1324	{
1325	D3DXMATRIX d3dMat = D3D9Mappings::makeD3DXMatrix( m );
1326
1327	if( mActiveRenderTarget->requiresTextureFlipping() )
1328	{
1329	// Invert transformed y
1330	d3dMat._12 = - d3dMat._12;
1331	d3dMat._22 = - d3dMat._22;
1332	d3dMat._32 = - d3dMat._32;
1333	d3dMat._42 = - d3dMat._42;
1334	}
1335
1336	HRESULT hr;
1337	if( FAILED( hr = mpD3DDevice->SetTransform( D3DTS_PROJECTION, &d3dMat ) ) )
1338	OGRE_EXCEPT( hr, "Cannot set D3D9 projection matrix", "D3D9RenderSystem::_setProjectionMatrix" );
1339	}
1340	//---------------------------------------------------------------------
1341	void D3D9RenderSystem::_setWorldMatrix( const Matrix4 &m )
1342	{
1343	D3DXMATRIX d3dMat = D3D9Mappings::makeD3DXMatrix( m );
1344
1345	HRESULT hr;
1346	if( FAILED( hr = mpD3DDevice->SetTransform( D3DTS_WORLD, &d3dMat ) ) )
1347	OGRE_EXCEPT( hr, "Cannot set D3D9 world matrix", "D3D9RenderSystem::_setWorldMatrix" );
1348	}
1349	//---------------------------------------------------------------------
1350	void D3D9RenderSystem::_setSurfaceParams( const ColourValue &ambient, const ColourValue &diffuse,
1351	const ColourValue &specular, const ColourValue &emissive, Real shininess,
1352	TrackVertexColourType tracking )
1353	{
1354
1355	D3DMATERIAL9 material;
1356	material.Diffuse = D3DXCOLOR( diffuse.r, diffuse.g, diffuse.b, diffuse.a );
1357	material.Ambient = D3DXCOLOR( ambient.r, ambient.g, ambient.b, ambient.a );
1358	material.Specular = D3DXCOLOR( specular.r, specular.g, specular.b, specular.a );
1359	material.Emissive = D3DXCOLOR( emissive.r, emissive.g, emissive.b, emissive.a );
1360	material.Power = shininess;
1361
1362	HRESULT hr = mpD3DDevice->SetMaterial( &material );
1363	if( FAILED( hr ) )
1364	OGRE_EXCEPT( hr, "Error setting D3D material", "D3D9RenderSystem::_setSurfaceParams" );
1365
1366
1367	if(tracking != TVC_NONE)
1368	{
1369	__SetRenderState(D3DRS_COLORVERTEX, TRUE);
1370	__SetRenderState(D3DRS_AMBIENTMATERIALSOURCE, (tracking&TVC_AMBIENT)?D3DMCS_COLOR1:D3DMCS_MATERIAL);
1371	__SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE, (tracking&TVC_DIFFUSE)?D3DMCS_COLOR1:D3DMCS_MATERIAL);
1372	__SetRenderState(D3DRS_SPECULARMATERIALSOURCE, (tracking&TVC_SPECULAR)?D3DMCS_COLOR1:D3DMCS_MATERIAL);
1373	__SetRenderState(D3DRS_EMISSIVEMATERIALSOURCE, (tracking&TVC_EMISSIVE)?D3DMCS_COLOR1:D3DMCS_MATERIAL);
1374	}
1375	else
1376	{
1377	__SetRenderState(D3DRS_COLORVERTEX, FALSE);
1378	}
1379
1380	}
1381	//---------------------------------------------------------------------
1382	void D3D9RenderSystem::_setPointParameters(Real size,
1383	bool attenuationEnabled, Real constant, Real linear, Real quadratic,
1384	Real minSize, Real maxSize)
1385	{
1386	if(attenuationEnabled)
1387	{
1388	// scaling required
1389	__SetRenderState(D3DRS_POINTSCALEENABLE, TRUE);
1390	__SetFloatRenderState(D3DRS_POINTSCALE_A, constant);
1391	__SetFloatRenderState(D3DRS_POINTSCALE_B, linear);
1392	__SetFloatRenderState(D3DRS_POINTSCALE_C, quadratic);
1393	}
1394	else
1395	{
1396	// no scaling required
1397	__SetRenderState(D3DRS_POINTSCALEENABLE, FALSE);
1398	}
1399	__SetFloatRenderState(D3DRS_POINTSIZE, size);
1400	__SetFloatRenderState(D3DRS_POINTSIZE_MIN, minSize);
1401	if (maxSize == 0.0f)
1402	maxSize = mCapabilities->getMaxPointSize();
1403	__SetFloatRenderState(D3DRS_POINTSIZE_MAX, maxSize);
1404
1405
1406	}
1407	//---------------------------------------------------------------------
1408	void D3D9RenderSystem::_setPointSpritesEnabled(bool enabled)
1409	{
1410	if (enabled)
1411	{
1412	__SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE);
1413	}
1414	else
1415	{
1416	__SetRenderState(D3DRS_POINTSPRITEENABLE, FALSE);
1417	}
1418	}
1419	//---------------------------------------------------------------------
1420	void D3D9RenderSystem::_setTexture( size_t stage, bool enabled, const String &texname )
1421	{
1422	HRESULT hr;
1423	D3D9TexturePtr dt = TextureManager::getSingleton().getByName(texname);
1424	if (enabled && !dt.isNull())
1425	{
1426	// note used
1427	dt->touch();
1428
1429	IDirect3DBaseTexture9 *pTex = dt->getTexture();
1430	if (mTexStageDesc[stage].pTex != pTex)
1431	{
1432	hr = mpD3DDevice->SetTexture(stage, pTex);
1433	if( hr != S_OK )
1434	{
1435	String str = "Unable to set texture '" + texname + "' in D3D9";
1436	OGRE_EXCEPT( hr, str, "D3D9RenderSystem::_setTexture" );
1437	}
1438
1439	// set stage desc.
1440	mTexStageDesc[stage].pTex = pTex;
1441	mTexStageDesc[stage].texType = D3D9Mappings::get(dt->getTextureType());
1442	}
1443	}
1444	else
1445	{
1446	if (mTexStageDesc[stage].pTex != 0)
1447	{
1448	hr = mpD3DDevice->SetTexture(stage, 0);
1449	if( hr != S_OK )
1450	{
1451	String str = "Unable to disable texture '" + texname + "' in D3D9";
1452	OGRE_EXCEPT( hr, str, "D3D9RenderSystem::_setTexture" );
1453	}
1454	}
1455
1456	hr = this->__SetTextureStageState(stage, D3DTSS_COLOROP, D3DTOP_DISABLE);
1457	if( hr != S_OK )
1458	{
1459	String str = "Unable to disable texture '" + texname + "' in D3D9";
1460	OGRE_EXCEPT( hr, str, "D3D9RenderSystem::_setTexture" );
1461	}
1462
1463	// set stage desc. to defaults
1464	mTexStageDesc[stage].pTex = 0;
1465	mTexStageDesc[stage].autoTexCoordType = TEXCALC_NONE;
1466	mTexStageDesc[stage].coordIndex = 0;
1467	mTexStageDesc[stage].texType = D3D9Mappings::D3D_TEX_TYPE_NORMAL;
1468	}
1469	}
1470	//---------------------------------------------------------------------
1471	void D3D9RenderSystem::_setTextureCoordSet( size_t stage, size_t index )
1472	{
1473	HRESULT hr;
1474	// Record settings
1475	mTexStageDesc[stage].coordIndex = index;
1476
1477	hr = __SetTextureStageState( stage, D3DTSS_TEXCOORDINDEX, D3D9Mappings::get(mTexStageDesc[stage].autoTexCoordType, mCaps) \| index );
1478	if( FAILED( hr ) )
1479	OGRE_EXCEPT( hr, "Unable to set texture coord. set index", "D3D8RenderSystem::_setTextureCoordSet" );
1480	}
1481	//---------------------------------------------------------------------
1482	void D3D9RenderSystem::_setTextureCoordCalculation( size_t stage, TexCoordCalcMethod m,
1483	const Frustum* frustum)
1484	{
1485	HRESULT hr;
1486	// record the stage state
1487	mTexStageDesc[stage].autoTexCoordType = m;
1488	mTexStageDesc[stage].frustum = frustum;
1489
1490	hr = __SetTextureStageState( stage, D3DTSS_TEXCOORDINDEX, D3D9Mappings::get(m, mCaps) \| mTexStageDesc[stage].coordIndex );
1491	if(FAILED(hr))
1492	OGRE_EXCEPT( hr, "Unable to set texture auto tex.coord. generation mode", "D3D8RenderSystem::_setTextureCoordCalculation" );
1493	}
1494	//---------------------------------------------------------------------
1495	void D3D9RenderSystem::_setTextureMatrix( size_t stage, const Matrix4& xForm )
1496	{
1497	HRESULT hr;
1498	D3DXMATRIX d3dMat; // the matrix we'll maybe apply
1499	Matrix4 newMat = xForm; // the matrix we'll apply after conv. to D3D format
1500	// Cache texcoord calc method to register
1501	TexCoordCalcMethod autoTexCoordType = mTexStageDesc[stage].autoTexCoordType;
1502
1503	if (autoTexCoordType == TEXCALC_ENVIRONMENT_MAP)
1504	{
1505	if (mCaps.VertexProcessingCaps & D3DVTXPCAPS_TEXGEN_SPHEREMAP)
1506	{
1507	/** Invert the texture for the spheremap */
1508	Matrix4 ogreMatEnvMap = Matrix4::IDENTITY;
1509	// set env_map values
1510	ogreMatEnvMap[1][1] = -1.0f;
1511	// concatenate with the xForm
1512	newMat = newMat.concatenate(ogreMatEnvMap);
1513	}
1514	else
1515	{
1516	/* If envmap is applied, but device doesn't support spheremap,
1517	then we have to use texture transform to make the camera space normal
1518	reference the envmap properly. This isn't exactly the same as spheremap
1519	(it looks nasty on flat areas because the camera space normals are the same)
1520	but it's the best approximation we have in the absence of a proper spheremap */
1521	// concatenate with the xForm
1522	newMat = newMat.concatenate(Matrix4::CLIPSPACE2DTOIMAGESPACE);
1523	}
1524	}
1525
1526	// If this is a cubic reflection, we need to modify using the view matrix
1527	if (autoTexCoordType == TEXCALC_ENVIRONMENT_MAP_REFLECTION)
1528	{
1529	// Get transposed 3x3
1530	// We want to transpose since that will invert an orthonormal matrix ie rotation
1531	Matrix4 ogreViewTransposed;
1532	ogreViewTransposed[0][0] = mViewMatrix[0][0];
1533	ogreViewTransposed[0][1] = mViewMatrix[1][0];
1534	ogreViewTransposed[0][2] = mViewMatrix[2][0];
1535	ogreViewTransposed[0][3] = 0.0f;
1536
1537	ogreViewTransposed[1][0] = mViewMatrix[0][1];
1538	ogreViewTransposed[1][1] = mViewMatrix[1][1];
1539	ogreViewTransposed[1][2] = mViewMatrix[2][1];
1540	ogreViewTransposed[1][3] = 0.0f;
1541
1542	ogreViewTransposed[2][0] = mViewMatrix[0][2];
1543	ogreViewTransposed[2][1] = mViewMatrix[1][2];
1544	ogreViewTransposed[2][2] = mViewMatrix[2][2];
1545	ogreViewTransposed[2][3] = 0.0f;
1546
1547	ogreViewTransposed[3][0] = 0.0f;
1548	ogreViewTransposed[3][1] = 0.0f;
1549	ogreViewTransposed[3][2] = 0.0f;
1550	ogreViewTransposed[3][3] = 1.0f;
1551
1552	newMat = newMat.concatenate(ogreViewTransposed);
1553	}
1554
1555	if (autoTexCoordType == TEXCALC_PROJECTIVE_TEXTURE)
1556	{
1557	// Derive camera space to projector space transform
1558	// To do this, we need to undo the camera view matrix, then
1559	// apply the projector view & projection matrices
1560	newMat = mViewMatrix.inverse();
1561	newMat = mTexStageDesc[stage].frustum->getViewMatrix() * newMat;
1562	newMat = mTexStageDesc[stage].frustum->getProjectionMatrix() * newMat;
1563	newMat = Matrix4::CLIPSPACE2DTOIMAGESPACE * newMat;
1564	newMat = xForm * newMat;
1565	}
1566
1567	// need this if texture is a cube map, to invert D3D's z coord
1568	if (autoTexCoordType != TEXCALC_NONE &&
1569	autoTexCoordType != TEXCALC_PROJECTIVE_TEXTURE)
1570	{
1571	newMat[2][0] = -newMat[2][0];
1572	newMat[2][1] = -newMat[2][1];
1573	newMat[2][2] = -newMat[2][2];
1574	newMat[2][3] = -newMat[2][3];
1575	}
1576
1577	// convert our matrix to D3D format
1578	d3dMat = D3D9Mappings::makeD3DXMatrix(newMat);
1579
1580	// set the matrix if it's not the identity
1581	if (!D3DXMatrixIsIdentity(&d3dMat))
1582	{
1583	/* It's seems D3D automatically add a texture coordinate with value 1,
1584	and fill up the remaining texture coordinates with 0 for the input
1585	texture coordinates before pass to texture coordinate transformation.
1586
1587	NOTE: It's difference with D3DDECLTYPE enumerated type expand in
1588	DirectX SDK documentation!
1589
1590	So we should prepare the texcoord transform, make the transformation
1591	just like standardized vector expand, thus, fill w with value 1 and
1592	others with 0.
1593	*/
1594	if (autoTexCoordType == TEXCALC_NONE)
1595	{
1596	/* FIXME: The actually input texture coordinate dimensions should
1597	be determine by texture coordinate vertex element. Now, just trust
1598	user supplied texture type matchs texture coordinate vertex element.
1599	*/
1600	if (mTexStageDesc[stage].texType == D3D9Mappings::D3D_TEX_TYPE_NORMAL)
1601	{
1602	/* It's 2D input texture coordinate:
1603
1604	texcoord in vertex buffer D3D expanded to We are adjusted to
1605	--> -->
1606	(u, v) (u, v, 1, 0) (u, v, 0, 1)
1607	*/
1608	std::swap(d3dMat._31, d3dMat._41);
1609	std::swap(d3dMat._32, d3dMat._42);
1610	std::swap(d3dMat._33, d3dMat._43);
1611	std::swap(d3dMat._34, d3dMat._44);
1612	}
1613	}
1614	else
1615	{
1616	// All texgen generate 3D input texture coordinates.
1617	}
1618
1619	// tell D3D the dimension of tex. coord.
1620	int texCoordDim = D3DTTFF_COUNT2;
1621	if (mTexStageDesc[stage].autoTexCoordType == TEXCALC_PROJECTIVE_TEXTURE)
1622	{
1623	/* We want texcoords (u, v, w, q) always get divided by q, but D3D
1624	projected texcoords is divided by the last element (in the case of
1625	2D texcoord, is w). So we tweak the transform matrix, transform the
1626	texcoords with w and q swapped: (u, v, q, w), and then D3D will
1627	divide u, v by q. The w and q just ignored as it wasn't used by
1628	rasterizer.
1629	*/
1630	switch (mTexStageDesc[stage].texType)
1631	{
1632	case D3D9Mappings::D3D_TEX_TYPE_NORMAL:
1633	std::swap(d3dMat._13, d3dMat._14);
1634	std::swap(d3dMat._23, d3dMat._24);
1635	std::swap(d3dMat._33, d3dMat._34);
1636	std::swap(d3dMat._43, d3dMat._44);
1637
1638	texCoordDim = D3DTTFF_PROJECTED \| D3DTTFF_COUNT3;
1639	break;
1640
1641	case D3D9Mappings::D3D_TEX_TYPE_CUBE:
1642	case D3D9Mappings::D3D_TEX_TYPE_VOLUME:
1643	// Yes, we support 3D projective texture.
1644	texCoordDim = D3DTTFF_PROJECTED \| D3DTTFF_COUNT4;
1645	break;
1646	}
1647	}
1648	else
1649	{
1650	switch (mTexStageDesc[stage].texType)
1651	{
1652	case D3D9Mappings::D3D_TEX_TYPE_NORMAL:
1653	texCoordDim = D3DTTFF_COUNT2;
1654	break;
1655	case D3D9Mappings::D3D_TEX_TYPE_CUBE:
1656	case D3D9Mappings::D3D_TEX_TYPE_VOLUME:
1657	texCoordDim = D3DTTFF_COUNT3;
1658	break;
1659	}
1660	}
1661
1662	hr = __SetTextureStageState( stage, D3DTSS_TEXTURETRANSFORMFLAGS, texCoordDim );
1663	if (FAILED(hr))
1664	OGRE_EXCEPT( hr, "Unable to set texture coord. dimension", "D3D9RenderSystem::_setTextureMatrix" );
1665
1666	hr = mpD3DDevice->SetTransform( (D3DTRANSFORMSTATETYPE)(D3DTS_TEXTURE0 + stage), &d3dMat );
1667	if (FAILED(hr))
1668	OGRE_EXCEPT( hr, "Unable to set texture matrix", "D3D9RenderSystem::_setTextureMatrix" );
1669	}
1670	else
1671	{
1672	// disable all of this
1673	hr = __SetTextureStageState( stage, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
1674	if( FAILED( hr ) )
1675	OGRE_EXCEPT( hr, "Error setting texture matrix", "D3D9RenderSystem::_setTextureMatrix" );
1676
1677	// set the identity matrix
1678	hr = mpD3DDevice->SetTransform( (D3DTRANSFORMSTATETYPE)(D3DTS_TEXTURE0 + stage), &d3dMat );
1679	if( FAILED( hr ) )
1680	OGRE_EXCEPT( hr, "Error setting texture matrix", "D3D9RenderSystem::_setTextureMatrix" );
1681	}
1682	}
1683	//---------------------------------------------------------------------
1684	void D3D9RenderSystem::_setTextureAddressingMode( size_t stage,
1685	const TextureUnitState::UVWAddressingMode& uvw )
1686	{
1687	HRESULT hr;
1688	if( FAILED( hr = __SetSamplerState( stage, D3DSAMP_ADDRESSU, D3D9Mappings::get(uvw.u) ) ) )
1689	OGRE_EXCEPT( hr, "Failed to set texture addressing mode for U", "D3D9RenderSystem::_setTextureAddressingMode" );
1690	if( FAILED( hr = __SetSamplerState( stage, D3DSAMP_ADDRESSV, D3D9Mappings::get(uvw.v) ) ) )
1691	OGRE_EXCEPT( hr, "Failed to set texture addressing mode for V", "D3D9RenderSystem::_setTextureAddressingMode" );
1692	if( FAILED( hr = __SetSamplerState( stage, D3DSAMP_ADDRESSW, D3D9Mappings::get(uvw.w) ) ) )
1693	OGRE_EXCEPT( hr, "Failed to set texture addressing mode for W", "D3D9RenderSystem::_setTextureAddressingMode" );
1694	}
1695	//-----------------------------------------------------------------------------
1696	void D3D9RenderSystem::_setTextureBorderColour(size_t stage,
1697	const ColourValue& colour)
1698	{
1699	HRESULT hr;
1700	if( FAILED( hr = __SetSamplerState( stage, D3DSAMP_BORDERCOLOR, colour.getAsARGB()) ) )
1701	OGRE_EXCEPT( hr, "Failed to set texture border colour", "D3D9RenderSystem::_setTextureBorderColour" );
1702	}
1703	//---------------------------------------------------------------------
1704	void D3D9RenderSystem::_setTextureBlendMode( size_t stage, const LayerBlendModeEx& bm )
1705	{
1706	HRESULT hr = S_OK;
1707	D3DTEXTURESTAGESTATETYPE tss;
1708	D3DCOLOR manualD3D;
1709
1710
1711	// choose type of blend.
1712	if( bm.blendType == LBT_COLOUR )
1713	tss = D3DTSS_COLOROP;
1714	else if( bm.blendType == LBT_ALPHA )
1715	tss = D3DTSS_ALPHAOP;
1716	else
1717	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
1718	"Invalid blend type", "D3D9RenderSystem::_setTextureBlendMode");
1719
1720	// set manual factor if required by operation
1721	if (bm.operation == LBX_BLEND_MANUAL)
1722	{
1723	hr = __SetRenderState( D3DRS_TEXTUREFACTOR, D3DXCOLOR(0.0, 0.0, 0.0, bm.factor) );
1724	if (FAILED(hr))
1725	OGRE_EXCEPT( hr, "Failed to set manual factor", "D3D9RenderSystem::_setTextureBlendMode" );
1726	}
1727	// set operation
1728	hr = __SetTextureStageState( stage, tss, D3D9Mappings::get(bm.operation, mCaps) );
1729	if (FAILED(hr))
1730	OGRE_EXCEPT( hr, "Failed to set operation", "D3D9RenderSystem::_setTextureBlendMode" );
1731
1732	// choose source 1
1733	if( bm.blendType == LBT_COLOUR )
1734	{
1735	tss = D3DTSS_COLORARG1;
1736	manualD3D = D3DXCOLOR( bm.colourArg1.r, bm.colourArg1.g, bm.colourArg1.b, bm.colourArg1.a );
1737	mManualBlendColours[stage][0] = bm.colourArg1;
1738	}
1739	else if( bm.blendType == LBT_ALPHA )
1740	{
1741	tss = D3DTSS_ALPHAARG1;
1742	manualD3D = D3DXCOLOR( mManualBlendColours[stage][0].r,
1743	mManualBlendColours[stage][0].g,
1744	mManualBlendColours[stage][0].b, bm.alphaArg1 );
1745	}
1746	else
1747	{
1748	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
1749	"Invalid blend type", "D3D9RenderSystem::_setTextureBlendMode");
1750	}
1751	// Set manual factor if required
1752	if (bm.source1 == LBS_MANUAL)
1753	{
1754	hr = __SetRenderState( D3DRS_TEXTUREFACTOR, manualD3D );
1755	if (FAILED(hr))
1756	OGRE_EXCEPT( hr, "Failed to set manual factor", "D3D9RenderSystem::_setTextureBlendMode" );
1757	}
1758	// set source 1
1759	hr = __SetTextureStageState( stage, tss, D3D9Mappings::get(bm.source1) );
1760	if (FAILED(hr))
1761	OGRE_EXCEPT( hr, "Failed to set source1", "D3D9RenderSystem::_setTextureBlendMode" );
1762
1763	// choose source 2
1764	if( bm.blendType == LBT_COLOUR )
1765	{
1766	tss = D3DTSS_COLORARG2;
1767	manualD3D = D3DXCOLOR( bm.colourArg2.r, bm.colourArg2.g, bm.colourArg2.b, bm.colourArg2.a );
1768	mManualBlendColours[stage][1] = bm.colourArg1;
1769	}
1770	else if( bm.blendType == LBT_ALPHA )
1771	{
1772	tss = D3DTSS_ALPHAARG2;
1773	manualD3D = D3DXCOLOR( mManualBlendColours[stage][1].r,
1774	mManualBlendColours[stage][1].g,
1775	mManualBlendColours[stage][1].b,
1776	bm.alphaArg2 );
1777	}
1778	// Set manual factor if required
1779	if (bm.source2 == LBS_MANUAL)
1780	{
1781	hr = __SetRenderState( D3DRS_TEXTUREFACTOR, manualD3D );
1782	if (FAILED(hr))
1783	OGRE_EXCEPT( hr, "Failed to set manual factor", "D3D9RenderSystem::_setTextureBlendMode" );
1784	}
1785	// Now set source 2
1786	hr = __SetTextureStageState( stage, tss, D3D9Mappings::get(bm.source2) );
1787	if (FAILED(hr))
1788	OGRE_EXCEPT( hr, "Failed to set source 2", "D3D9RenderSystem::_setTextureBlendMode" );
1789
1790	// Set interpolation factor if lerping
1791	if (bm.operation == LBX_BLEND_DIFFUSE_COLOUR &&
1792	mCaps.TextureOpCaps & D3DTEXOPCAPS_LERP)
1793	{
1794	// choose source 0 (lerp factor)
1795	if( bm.blendType == LBT_COLOUR )
1796	{
1797	tss = D3DTSS_COLORARG0;
1798	}
1799	else if( bm.blendType == LBT_ALPHA )
1800	{
1801	tss = D3DTSS_ALPHAARG0;
1802	}
1803	hr = __SetTextureStageState(stage, tss, D3DTA_DIFFUSE);
1804
1805	if (FAILED(hr))
1806	OGRE_EXCEPT( hr, "Failed to set lerp source 0",
1807	"D3D9RenderSystem::_setTextureBlendMode" );
1808
1809	}
1810	}
1811	//---------------------------------------------------------------------
1812	void D3D9RenderSystem::_setSceneBlending( SceneBlendFactor sourceFactor, SceneBlendFactor destFactor )
1813	{
1814	HRESULT hr;
1815	if( sourceFactor == SBF_ONE && destFactor == SBF_ZERO)
1816	{
1817	if (FAILED(hr = __SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE)))
1818	OGRE_EXCEPT( hr, "Failed to set alpha blending option", "D3D9RenderSystem::_setSceneBlending" );
1819	}
1820	else
1821	{
1822	if (FAILED(hr = __SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE)))
1823	OGRE_EXCEPT( hr, "Failed to set alpha blending option", "D3D9RenderSystem::_setSceneBlending" );
1824	if( FAILED( hr = __SetRenderState( D3DRS_SRCBLEND, D3D9Mappings::get(sourceFactor) ) ) )
1825	OGRE_EXCEPT( hr, "Failed to set source blend", "D3D9RenderSystem::_setSceneBlending" );
1826	if( FAILED( hr = __SetRenderState( D3DRS_DESTBLEND, D3D9Mappings::get(destFactor) ) ) )
1827	OGRE_EXCEPT( hr, "Failed to set destination blend", "D3D9RenderSystem::_setSceneBlending" );
1828	}
1829	}
1830	//---------------------------------------------------------------------
1831	void D3D9RenderSystem::_setAlphaRejectSettings( CompareFunction func, unsigned char value )
1832	{
1833	HRESULT hr;
1834	if (func != CMPF_ALWAYS_PASS)
1835	{
1836	if( FAILED( hr = __SetRenderState( D3DRS_ALPHATESTENABLE, TRUE ) ) )
1837	OGRE_EXCEPT( hr, "Failed to enable alpha testing",
1838	"D3D9RenderSystem::_setAlphaRejectSettings" );
1839	}
1840	else
1841	{
1842	if( FAILED( hr = __SetRenderState( D3DRS_ALPHATESTENABLE, FALSE ) ) )
1843	OGRE_EXCEPT( hr, "Failed to disable alpha testing",
1844	"D3D9RenderSystem::_setAlphaRejectSettings" );
1845	}
1846	// Set always just be sure
1847	if( FAILED( hr = __SetRenderState( D3DRS_ALPHAFUNC, D3D9Mappings::get(func) ) ) )
1848	OGRE_EXCEPT( hr, "Failed to set alpha reject function", "D3D9RenderSystem::_setAlphaRejectSettings" );
1849	if( FAILED( hr = __SetRenderState( D3DRS_ALPHAREF, value ) ) )
1850	OGRE_EXCEPT( hr, "Failed to set render state D3DRS_ALPHAREF", "D3D9RenderSystem::_setAlphaRejectSettings" );
1851	}
1852	//---------------------------------------------------------------------
1853	void D3D9RenderSystem::_setCullingMode( CullingMode mode )
1854	{
1855	HRESULT hr;
1856	bool flip = ((mActiveRenderTarget->requiresTextureFlipping() && !mInvertVertexWinding) \|\|
1857	(!mActiveRenderTarget->requiresTextureFlipping() && mInvertVertexWinding));
1858
1859	if( FAILED (hr = __SetRenderState(D3DRS_CULLMODE,
1860	D3D9Mappings::get(mode, flip))) )
1861	OGRE_EXCEPT( hr, "Failed to set culling mode", "D3D9RenderSystem::_setCullingMode" );
1862	}
1863	//---------------------------------------------------------------------
1864	void D3D9RenderSystem::_setDepthBufferParams( bool depthTest, bool depthWrite, CompareFunction depthFunction )
1865	{
1866	_setDepthBufferCheckEnabled( depthTest );
1867	_setDepthBufferWriteEnabled( depthWrite );
1868	_setDepthBufferFunction( depthFunction );
1869	}
1870	//---------------------------------------------------------------------
1871	void D3D9RenderSystem::_setDepthBufferCheckEnabled( bool enabled )
1872	{
1873	HRESULT hr;
1874
1875	if( enabled )
1876	{
1877	// Use w-buffer if available and enabled
1878	if( mWBuffer && mCaps.RasterCaps & D3DPRASTERCAPS_WBUFFER )
1879	hr = __SetRenderState( D3DRS_ZENABLE, D3DZB_USEW );
1880	else
1881	hr = __SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE );
1882	}
1883	else
1884	hr = __SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );
1885
1886	if( FAILED( hr ) )
1887	OGRE_EXCEPT( hr, "Error setting depth buffer test state", "D3D9RenderSystem::_setDepthBufferCheckEnabled" );
1888	}
1889	//---------------------------------------------------------------------
1890	void D3D9RenderSystem::_setDepthBufferWriteEnabled( bool enabled )
1891	{
1892	HRESULT hr;
1893
1894	if( FAILED( hr = __SetRenderState( D3DRS_ZWRITEENABLE, enabled ) ) )
1895	OGRE_EXCEPT( hr, "Error setting depth buffer write state", "D3D9RenderSystem::_setDepthBufferWriteEnabled" );
1896	}
1897	//---------------------------------------------------------------------
1898	void D3D9RenderSystem::_setDepthBufferFunction( CompareFunction func )
1899	{
1900	HRESULT hr;
1901	if( FAILED( hr = __SetRenderState( D3DRS_ZFUNC, D3D9Mappings::get(func) ) ) )
1902	OGRE_EXCEPT( hr, "Error setting depth buffer test function", "D3D9RenderSystem::_setDepthBufferFunction" );
1903	}
1904	//---------------------------------------------------------------------
1905	void D3D9RenderSystem::_setDepthBias(ushort bias)
1906	{
1907	float bias_float = static_cast<float>(-bias);
1908	// scale down - certainly needed for nVidia
1909	bias_float /= 250000.0f;
1910	HRESULT hr = __SetRenderState(D3DRS_DEPTHBIAS, (DWORD)&bias_float);
1911	if (FAILED(hr))
1912	OGRE_EXCEPT(hr, "Error setting depth bias", "D3D9RenderSystem::_setDepthBias");
1913	}
1914	//---------------------------------------------------------------------
1915	void D3D9RenderSystem::_setColourBufferWriteEnabled(bool red, bool green,
1916	bool blue, bool alpha)
1917	{
1918	DWORD val = 0;
1919	if (red)
1920	val \|= D3DCOLORWRITEENABLE_RED;
1921	if (green)
1922	val \|= D3DCOLORWRITEENABLE_GREEN;
1923	if (blue)
1924	val \|= D3DCOLORWRITEENABLE_BLUE;
1925	if (alpha)
1926	val \|= D3DCOLORWRITEENABLE_ALPHA;
1927	HRESULT hr = __SetRenderState(D3DRS_COLORWRITEENABLE, val);
1928	if (FAILED(hr))
1929	OGRE_EXCEPT(hr, "Error setting colour write enable flags",
1930	"D3D9RenderSystem::_setColourBufferWriteEnabled");
1931	}
1932	//---------------------------------------------------------------------
1933	void D3D9RenderSystem::_setFog( FogMode mode, const ColourValue& colour, Real densitiy, Real start, Real end )
1934	{
1935	HRESULT hr;
1936
1937	D3DRENDERSTATETYPE fogType, fogTypeNot;
1938
1939	if (mCaps.RasterCaps & D3DPRASTERCAPS_FOGTABLE)
1940	{
1941	fogType = D3DRS_FOGTABLEMODE;
1942	fogTypeNot = D3DRS_FOGVERTEXMODE;
1943	}
1944	else
1945	{
1946	fogType = D3DRS_FOGVERTEXMODE;
1947	fogTypeNot = D3DRS_FOGTABLEMODE;
1948	}
1949
1950	if( mode == FOG_NONE)
1951	{
1952	// just disable
1953	hr = __SetRenderState(fogType, D3DFOG_NONE );
1954	hr = __SetRenderState(D3DRS_FOGENABLE, FALSE);
1955	}
1956	else
1957	{
1958	// Allow fog
1959	hr = __SetRenderState( D3DRS_FOGENABLE, TRUE );
1960	hr = __SetRenderState( fogTypeNot, D3DFOG_NONE );
1961	hr = __SetRenderState( fogType, D3D9Mappings::get(mode) );
1962
1963	hr = __SetRenderState( D3DRS_FOGCOLOR, colour.getAsARGB() );
1964	hr = __SetFloatRenderState( D3DRS_FOGSTART, start );
1965	hr = __SetFloatRenderState( D3DRS_FOGEND, end );
1966	hr = __SetFloatRenderState( D3DRS_FOGDENSITY, densitiy );
1967	}
1968
1969	if( FAILED( hr ) )
1970	OGRE_EXCEPT( hr, "Error setting render state", "D3D9RenderSystem::_setFog" );
1971	}
1972	//---------------------------------------------------------------------
1973	void D3D9RenderSystem::_setPolygonMode(PolygonMode level)
1974	{
1975	HRESULT hr = __SetRenderState(D3DRS_FILLMODE, D3D9Mappings::get(level));
1976	if (FAILED(hr))
1977	OGRE_EXCEPT(hr, "Error setting polygon mode.", "D3D9RenderSystem::setPolygonMode");
1978	}
1979	//---------------------------------------------------------------------
1980	void D3D9RenderSystem::setStencilCheckEnabled(bool enabled)
1981	{
1982	// Allow stencilling
1983	HRESULT hr = __SetRenderState(D3DRS_STENCILENABLE, enabled);
1984	if (FAILED(hr))
1985	OGRE_EXCEPT(hr, "Error enabling / disabling stencilling.",
1986	"D3D9RenderSystem::setStencilCheckEnabled");
1987	}
1988	//---------------------------------------------------------------------
1989	void D3D9RenderSystem::setStencilBufferParams(CompareFunction func,
1990	uint32 refValue, uint32 mask, StencilOperation stencilFailOp,
1991	StencilOperation depthFailOp, StencilOperation passOp,
1992	bool twoSidedOperation)
1993	{
1994	HRESULT hr;
1995	bool flip;
1996
1997	// 2-sided operation
1998	if (twoSidedOperation)
1999	{
2000	if (!mCapabilities->hasCapability(RSC_TWO_SIDED_STENCIL))
2001	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "2-sided stencils are not supported",
2002	"D3D9RenderSystem::setStencilBufferParams");
2003	hr = __SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, TRUE);
2004	if (FAILED(hr))
2005	OGRE_EXCEPT(hr, "Error setting 2-sided stencil mode.",
2006	"D3D9RenderSystem::setStencilBufferParams");
2007	// NB: We should always treat CCW as front face for consistent with default
2008	// culling mode. Therefore, we must take care with two-sided stencil settings.
2009	flip = (mInvertVertexWinding && mActiveRenderTarget->requiresTextureFlipping()) \|\|
2010	(!mInvertVertexWinding && !mActiveRenderTarget->requiresTextureFlipping());
2011
2012	// Set alternative versions of ops
2013	// fail op
2014	hr = __SetRenderState(D3DRS_CCW_STENCILFAIL, D3D9Mappings::get(stencilFailOp, !flip));
2015	if (FAILED(hr))
2016	OGRE_EXCEPT(hr, "Error setting stencil fail operation (2-sided).",
2017	"D3D9RenderSystem::setStencilBufferParams");
2018
2019	// depth fail op
2020	hr = __SetRenderState(D3DRS_CCW_STENCILZFAIL, D3D9Mappings::get(depthFailOp, !flip));
2021	if (FAILED(hr))
2022	OGRE_EXCEPT(hr, "Error setting stencil depth fail operation (2-sided).",
2023	"D3D9RenderSystem::setStencilBufferParams");
2024
2025	// pass op
2026	hr = __SetRenderState(D3DRS_CCW_STENCILPASS, D3D9Mappings::get(passOp, !flip));
2027	if (FAILED(hr))
2028	OGRE_EXCEPT(hr, "Error setting stencil pass operation (2-sided).",
2029	"D3D9RenderSystem::setStencilBufferParams");
2030	}
2031	else
2032	{
2033	hr = __SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, FALSE);
2034	if (FAILED(hr))
2035	OGRE_EXCEPT(hr, "Error setting 1-sided stencil mode.",
2036	"D3D9RenderSystem::setStencilBufferParams");
2037	flip = false;
2038	}
2039
2040	// func
2041	hr = __SetRenderState(D3DRS_STENCILFUNC, D3D9Mappings::get(func));
2042	if (FAILED(hr))
2043	OGRE_EXCEPT(hr, "Error setting stencil buffer test function.",
2044	"D3D9RenderSystem::setStencilBufferParams");
2045
2046	// reference value
2047	hr = __SetRenderState(D3DRS_STENCILREF, refValue);
2048	if (FAILED(hr))
2049	OGRE_EXCEPT(hr, "Error setting stencil buffer reference value.",
2050	"D3D9RenderSystem::setStencilBufferParams");
2051
2052	// mask
2053	hr = __SetRenderState(D3DRS_STENCILMASK, mask);
2054	if (FAILED(hr))
2055	OGRE_EXCEPT(hr, "Error setting stencil buffer mask.",
2056	"D3D9RenderSystem::setStencilBufferParams");
2057
2058	// fail op
2059	hr = __SetRenderState(D3DRS_STENCILFAIL, D3D9Mappings::get(stencilFailOp, flip));
2060	if (FAILED(hr))
2061	OGRE_EXCEPT(hr, "Error setting stencil fail operation.",
2062	"D3D9RenderSystem::setStencilBufferParams");
2063
2064	// depth fail op
2065	hr = __SetRenderState(D3DRS_STENCILZFAIL, D3D9Mappings::get(depthFailOp, flip));
2066	if (FAILED(hr))
2067	OGRE_EXCEPT(hr, "Error setting stencil depth fail operation.",
2068	"D3D9RenderSystem::setStencilBufferParams");
2069
2070	// pass op
2071	hr = __SetRenderState(D3DRS_STENCILPASS, D3D9Mappings::get(passOp, flip));
2072	if (FAILED(hr))
2073	OGRE_EXCEPT(hr, "Error setting stencil pass operation.",
2074	"D3D9RenderSystem::setStencilBufferParams");
2075	}
2076	//---------------------------------------------------------------------
2077	void D3D9RenderSystem::_setTextureUnitFiltering(size_t unit, FilterType ftype,
2078	FilterOptions filter)
2079	{
2080	HRESULT hr;
2081	D3D9Mappings::eD3DTexType texType = mTexStageDesc[unit].texType;
2082	hr = __SetSamplerState( unit, D3D9Mappings::get(ftype),
2083	D3D9Mappings::get(ftype, filter, mCaps, texType));
2084	if (FAILED(hr))
2085	OGRE_EXCEPT(hr, "Failed to set texture filter ", "D3D9RenderSystem::_setTextureUnitFiltering");
2086	}
2087	//---------------------------------------------------------------------
2088	DWORD D3D9RenderSystem::_getCurrentAnisotropy(size_t unit)
2089	{
2090	DWORD oldVal;
2091	mpD3DDevice->GetSamplerState(unit, D3DSAMP_MAXANISOTROPY, &oldVal);
2092	return oldVal;
2093	}
2094	//---------------------------------------------------------------------
2095	void D3D9RenderSystem::_setTextureLayerAnisotropy(size_t unit, unsigned int maxAnisotropy)
2096	{
2097	if ((DWORD)maxAnisotropy > mCaps.MaxAnisotropy)
2098	maxAnisotropy = mCaps.MaxAnisotropy;
2099
2100	if (_getCurrentAnisotropy(unit) != maxAnisotropy)
2101	__SetSamplerState( unit, D3DSAMP_MAXANISOTROPY, maxAnisotropy );
2102	}
2103	//---------------------------------------------------------------------
2104	HRESULT D3D9RenderSystem::__SetRenderState(D3DRENDERSTATETYPE state, DWORD value)
2105	{
2106	HRESULT hr;
2107	DWORD oldVal;
2108
2109	if ( FAILED( hr = mpD3DDevice->GetRenderState(state, &oldVal) ) )
2110	return hr;
2111	if ( oldVal == value )
2112	return D3D_OK;
2113	else
2114	return mpD3DDevice->SetRenderState(state, value);
2115	}
2116	//---------------------------------------------------------------------
2117	HRESULT D3D9RenderSystem::__SetSamplerState(DWORD sampler, D3DSAMPLERSTATETYPE type, DWORD value)
2118	{
2119	HRESULT hr;
2120	DWORD oldVal;
2121
2122	if ( FAILED( hr = mpD3DDevice->GetSamplerState(sampler, type, &oldVal) ) )
2123	return hr;
2124	if ( oldVal == value )
2125	return D3D_OK;
2126	else
2127	return mpD3DDevice->SetSamplerState(sampler, type, value);
2128	}
2129	//---------------------------------------------------------------------
2130	HRESULT D3D9RenderSystem::__SetTextureStageState(DWORD stage, D3DTEXTURESTAGESTATETYPE type, DWORD value)
2131	{
2132	HRESULT hr;
2133	DWORD oldVal;
2134
2135	if ( FAILED( hr = mpD3DDevice->GetTextureStageState(stage, type, &oldVal) ) )
2136	return hr;
2137	if ( oldVal == value )
2138	return D3D_OK;
2139	else
2140	return mpD3DDevice->SetTextureStageState(stage, type, value);
2141	}
2142	//---------------------------------------------------------------------
2143	void D3D9RenderSystem::_setViewport( Viewport *vp )
2144	{
2145	if( vp != mActiveViewport \|\| vp->_isUpdated() )
2146	{
2147	mActiveViewport = vp;
2148	mActiveRenderTarget = vp->getTarget();
2149
2150	// ok, it's different, time to set render target and viewport params
2151	D3DVIEWPORT9 d3dvp;
2152	HRESULT hr;
2153
2154	// Set render target
2155	RenderTarget* target;
2156	target = vp->getTarget();
2157
2158	// Retrieve render surfaces (up to OGRE_MAX_MULTIPLE_RENDER_TARGETS)
2159	LPDIRECT3DSURFACE9 pBack[OGRE_MAX_MULTIPLE_RENDER_TARGETS];
2160	memset(pBack, 0, sizeof(pBack));
2161	target->getCustomAttribute( "DDBACKBUFFER", &pBack );
2162	if (!pBack[0])
2163	return;
2164
2165	LPDIRECT3DSURFACE9 pDepth = NULL;
2166	target->getCustomAttribute( "D3DZBUFFER", &pDepth );
2167	if (!pDepth)
2168	{
2169	/// No depth buffer provided, use our own
2170	/// Request a depth stencil that is compatible with the format, multisample type and
2171	/// dimensions of the render target.
2172	D3DSURFACE_DESC srfDesc;
2173	if(FAILED(pBack[0]->GetDesc(&srfDesc)))
2174	return; // ?
2175	pDepth = _getDepthStencilFor(srfDesc.Format, srfDesc.MultiSampleType, srfDesc.Width, srfDesc.Height);
2176	}
2177	// Bind render targets
2178	uint count = mCapabilities->numMultiRenderTargets();
2179	for(uint x=0; x<count; ++x)
2180	{
2181	hr = mpD3DDevice->SetRenderTarget(x, pBack[x]);
2182	if (FAILED(hr))
2183	{
2184	String msg = DXGetErrorDescription9(hr);
2185	OGRE_EXCEPT( hr, "Failed to setRenderTarget : " + msg, "D3D9RenderSystem::_setViewport" );
2186	}
2187	}
2188	hr = mpD3DDevice->SetDepthStencilSurface(pDepth);
2189	if (FAILED(hr))
2190	{
2191	String msg = DXGetErrorDescription9(hr);
2192	OGRE_EXCEPT( hr, "Failed to setDepthStencil : " + msg, "D3D9RenderSystem::_setViewport" );
2193	}
2194
2195	_setCullingMode( mCullingMode );
2196
2197	// set viewport dimensions
2198	d3dvp.X = vp->getActualLeft();
2199	d3dvp.Y = vp->getActualTop();
2200	d3dvp.Width = vp->getActualWidth();
2201	d3dvp.Height = vp->getActualHeight();
2202	if (target->requiresTextureFlipping())
2203	{
2204	// Convert "top-left" to "bottom-left"
2205	d3dvp.Y = target->getHeight() - d3dvp.Height - d3dvp.Y;
2206	}
2207
2208	// Z-values from 0.0 to 1.0 (TODO: standardise with OpenGL)
2209	d3dvp.MinZ = 0.0f;
2210	d3dvp.MaxZ = 1.0f;
2211
2212	if( FAILED( hr = mpD3DDevice->SetViewport( &d3dvp ) ) )
2213	OGRE_EXCEPT( hr, "Failed to set viewport.", "D3D9RenderSystem::_setViewport" );
2214
2215	vp->_clearUpdatedFlag();
2216	}
2217	}
2218	//---------------------------------------------------------------------
2219	void D3D9RenderSystem::_beginFrame()
2220	{
2221	OgreGuard( "D3D9RenderSystem::_beginFrame" );
2222
2223	HRESULT hr;
2224
2225	if( !mActiveViewport )
2226	OGRE_EXCEPT( Exception::ERR_INTERNAL_ERROR, "Cannot begin frame - no viewport selected.", "D3D9RenderSystem::_beginFrame" );
2227
2228	// Clear the viewport if required
2229	if( mActiveViewport->getClearEveryFrame() )
2230	{
2231	clearFrameBuffer(mActiveViewport->getClearBuffers(),
2232	mActiveViewport->getBackgroundColour());
2233	}
2234
2235	if( FAILED( hr = mpD3DDevice->BeginScene() ) )
2236	{
2237	String msg = DXGetErrorDescription9(hr);
2238	OGRE_EXCEPT( hr, "Error beginning frame :" + msg, "D3D9RenderSystem::_beginFrame" );
2239	}
2240
2241	if(!mBasicStatesInitialised)
2242	{
2243	// First-time
2244	// setup some defaults
2245	// Allow specular
2246	hr = __SetRenderState(D3DRS_SPECULARENABLE, TRUE);
2247	if (FAILED(hr))
2248	{
2249	String msg = DXGetErrorDescription9(hr);
2250	OGRE_EXCEPT(hr, "Error enabling alpha blending option : " + msg, "D3D9RenderSystem::_beginFrame");
2251	}
2252	mBasicStatesInitialised = true;
2253	}
2254
2255	OgreUnguard();
2256	}
2257	//---------------------------------------------------------------------
2258	void D3D9RenderSystem::_endFrame()
2259	{
2260	OgreGuard( "D3D9RenderSystem::_endFrame" );
2261
2262	HRESULT hr;
2263	if( FAILED( hr = mpD3DDevice->EndScene() ) )
2264	OGRE_EXCEPT( hr, "Error ending frame", "D3D9RenderSystem::_endFrame" );
2265
2266	OgreUnguard();
2267	}
2268	//---------------------------------------------------------------------
2269	inline bool D3D9RenderSystem::compareDecls( D3DVERTEXELEMENT9* pDecl1, D3DVERTEXELEMENT9* pDecl2, size_t size )
2270	{
2271	for( size_t i=0; i < size; i++ )
2272	{
2273	if( pDecl1[i].Method != pDecl2[i].Method \|\|
2274	pDecl1[i].Offset != pDecl2[i].Offset \|\|
2275	pDecl1[i].Stream != pDecl2[i].Stream \|\|
2276	pDecl1[i].Type != pDecl2[i].Type \|\|
2277	pDecl1[i].Usage != pDecl2[i].Usage \|\|
2278	pDecl1[i].UsageIndex != pDecl2[i].UsageIndex)
2279	{
2280	return false;
2281	}
2282	}
2283
2284	return true;
2285	}
2286	//---------------------------------------------------------------------
2287	void D3D9RenderSystem::setVertexDeclaration(VertexDeclaration* decl)
2288	{
2289	// Guard
2290	OgreGuard ("D3D9RenderSystem::setVertexDeclaration");
2291	HRESULT hr;
2292
2293	D3D9VertexDeclaration* d3ddecl =
2294	static_cast<D3D9VertexDeclaration*>(decl);
2295
2296	if (FAILED(hr = mpD3DDevice->SetVertexDeclaration(d3ddecl->getD3DVertexDeclaration())))
2297	{
2298	OGRE_EXCEPT(hr, "Unable to set D3D9 vertex declaration",
2299	"D3D9RenderSystem::setVertexDeclaration");
2300	}
2301
2302	// UnGuard
2303	OgreUnguard();
2304	}
2305	//---------------------------------------------------------------------
2306	void D3D9RenderSystem::setVertexBufferBinding(VertexBufferBinding* binding)
2307	{
2308	// Guard
2309	OgreGuard ("D3D9RenderSystem::setVertexBufferBinding");
2310
2311	HRESULT hr;
2312
2313	// TODO: attempt to detect duplicates
2314	const VertexBufferBinding::VertexBufferBindingMap& binds = binding->getBindings();
2315	VertexBufferBinding::VertexBufferBindingMap::const_iterator i, iend;
2316	iend = binds.end();
2317	for (i = binds.begin(); i != iend; ++i)
2318	{
2319	const D3D9HardwareVertexBuffer* d3d9buf =
2320	static_cast<const D3D9HardwareVertexBuffer*>(i->second.get());
2321	hr = mpD3DDevice->SetStreamSource(
2322	static_cast<UINT>(i->first),
2323	d3d9buf->getD3D9VertexBuffer(),
2324	0, // no stream offset, this is handled in _render instead
2325	static_cast<UINT>(d3d9buf->getVertexSize()) // stride
2326	);
2327	if (FAILED(hr))
2328	{
2329	OGRE_EXCEPT(hr, "Unable to set D3D9 stream source for buffer binding",
2330	"D3D9RenderSystem::setVertexBufferBinding");
2331	}
2332
2333
2334	}
2335
2336	// Unbind any unused sources
2337	for (size_t unused = binds.size(); unused < mLastVertexSourceCount; ++unused)
2338	{
2339
2340	hr = mpD3DDevice->SetStreamSource(static_cast<UINT>(unused), NULL, 0, 0);
2341	if (FAILED(hr))
2342	{
2343	OGRE_EXCEPT(hr, "Unable to reset unused D3D9 stream source",
2344	"D3D9RenderSystem::setVertexBufferBinding");
2345	}
2346
2347	}
2348	mLastVertexSourceCount = binds.size();
2349
2350
2351
2352	// UnGuard
2353	OgreUnguard();
2354	}
2355	//---------------------------------------------------------------------
2356	void D3D9RenderSystem::_render(const RenderOperation& op)
2357	{
2358	// Guard
2359	OgreGuard ("D3D9RenderSystem::_render");
2360
2361	// Exit immediately if there is nothing to render
2362	// This caused a problem on FireGL 8800
2363	if (op.vertexData->vertexCount == 0)
2364	return;
2365
2366	// Call super class
2367	RenderSystem::_render(op);
2368
2369	// To think about: possibly remove setVertexDeclaration and
2370	// setVertexBufferBinding from RenderSystem since the sequence is
2371	// a bit too D3D9-specific?
2372	setVertexDeclaration(op.vertexData->vertexDeclaration);
2373	setVertexBufferBinding(op.vertexData->vertexBufferBinding);
2374
2375	// Determine rendering operation
2376	D3DPRIMITIVETYPE primType = D3DPT_TRIANGLELIST;
2377	DWORD primCount = 0;
2378	switch( op.operationType )
2379	{
2380	case RenderOperation::OT_POINT_LIST:
2381	primType = D3DPT_POINTLIST;
2382	primCount = (DWORD)(op.useIndexes ? op.indexData->indexCount : op.vertexData->vertexCount);
2383	break;
2384
2385	case RenderOperation::OT_LINE_LIST:
2386	primType = D3DPT_LINELIST;
2387	primCount = (DWORD)(op.useIndexes ? op.indexData->indexCount : op.vertexData->vertexCount) / 2;
2388	break;
2389
2390	case RenderOperation::OT_LINE_STRIP:
2391	primType = D3DPT_LINESTRIP;
2392	primCount = (DWORD)(op.useIndexes ? op.indexData->indexCount : op.vertexData->vertexCount) - 1;
2393	break;
2394
2395	case RenderOperation::OT_TRIANGLE_LIST:
2396	primType = D3DPT_TRIANGLELIST;
2397	primCount = (DWORD)(op.useIndexes ? op.indexData->indexCount : op.vertexData->vertexCount) / 3;
2398	break;
2399
2400	case RenderOperation::OT_TRIANGLE_STRIP:
2401	primType = D3DPT_TRIANGLESTRIP;
2402	primCount = (DWORD)(op.useIndexes ? op.indexData->indexCount : op.vertexData->vertexCount) - 2;
2403	break;
2404
2405	case RenderOperation::OT_TRIANGLE_FAN:
2406	primType = D3DPT_TRIANGLEFAN;
2407	primCount = (DWORD)(op.useIndexes ? op.indexData->indexCount : op.vertexData->vertexCount) - 2;
2408	break;
2409	}
2410
2411	if (!primCount)
2412	return;
2413
2414	// Issue the op
2415	HRESULT hr;
2416	if( op.useIndexes )
2417	{
2418	D3D9HardwareIndexBuffer* d3dIdxBuf =
2419	static_cast<D3D9HardwareIndexBuffer*>(op.indexData->indexBuffer.get());
2420	hr = mpD3DDevice->SetIndices( d3dIdxBuf->getD3DIndexBuffer() );
2421	if (FAILED(hr))
2422	{
2423	OGRE_EXCEPT( hr, "Failed to set index buffer", "D3D9RenderSystem::_render" );
2424	}
2425
2426	do
2427	{
2428	// do indexed draw operation
2429	hr = mpD3DDevice->DrawIndexedPrimitive(
2430	primType,
2431	static_cast<INT>(op.vertexData->vertexStart),
2432	0, // Min vertex index - assume we can go right down to 0
2433	static_cast<UINT>(op.vertexData->vertexCount),
2434	static_cast<UINT>(op.indexData->indexStart),
2435	static_cast<UINT>(primCount)
2436	);
2437
2438	} while (updatePassIterationRenderState());
2439	}
2440	else
2441	{
2442	// nfz: gpu_iterate
2443	do
2444	{
2445	// Unindexed, a little simpler!
2446	hr = mpD3DDevice->DrawPrimitive(
2447	primType,
2448	static_cast<UINT>(op.vertexData->vertexStart),
2449	static_cast<UINT>(primCount)
2450	);
2451
2452	} while (updatePassIterationRenderState());
2453	}
2454
2455	if( FAILED( hr ) )
2456	{
2457	String msg = DXGetErrorDescription9(hr);
2458	OGRE_EXCEPT( hr, "Failed to DrawPrimitive : " + msg, "D3D9RenderSystem::_render" );
2459	}
2460
2461	// UnGuard
2462	OgreUnguard();
2463
2464	}
2465	//---------------------------------------------------------------------
2466	void D3D9RenderSystem::setNormaliseNormals(bool normalise)
2467	{
2468	__SetRenderState(D3DRS_NORMALIZENORMALS,
2469	normalise ? TRUE : FALSE);
2470	}
2471	//---------------------------------------------------------------------
2472	void D3D9RenderSystem::bindGpuProgram(GpuProgram* prg)
2473	{
2474	HRESULT hr;
2475	switch (prg->getType())
2476	{
2477	case GPT_VERTEX_PROGRAM:
2478	hr = mpD3DDevice->SetVertexShader(
2479	static_cast<D3D9GpuVertexProgram*>(prg)->getVertexShader());
2480	if (FAILED(hr))
2481	{
2482	OGRE_EXCEPT(hr, "Error calling SetVertexShader", "D3D9RenderSystem::bindGpuProgram");
2483	}
2484	break;
2485	case GPT_FRAGMENT_PROGRAM:
2486	hr = mpD3DDevice->SetPixelShader(
2487	static_cast<D3D9GpuFragmentProgram*>(prg)->getPixelShader());
2488	if (FAILED(hr))
2489	{
2490	OGRE_EXCEPT(hr, "Error calling SetPixelShader", "D3D9RenderSystem::bindGpuProgram");
2491	}
2492	break;
2493	};
2494
2495	RenderSystem::bindGpuProgram(prg);
2496
2497	}
2498	//---------------------------------------------------------------------
2499	void D3D9RenderSystem::unbindGpuProgram(GpuProgramType gptype)
2500	{
2501	HRESULT hr;
2502	switch(gptype)
2503	{
2504	case GPT_VERTEX_PROGRAM:
2505	mActiveVertexGpuProgramParameters.setNull();
2506	hr = mpD3DDevice->SetVertexShader(NULL);
2507	if (FAILED(hr))
2508	{
2509	OGRE_EXCEPT(hr, "Error resetting SetVertexShader to NULL",
2510	"D3D9RenderSystem::unbindGpuProgram");
2511	}
2512	break;
2513	case GPT_FRAGMENT_PROGRAM:
2514	mActiveFragmentGpuProgramParameters.setNull();
2515	hr = mpD3DDevice->SetPixelShader(NULL);
2516	if (FAILED(hr))
2517	{
2518	OGRE_EXCEPT(hr, "Error resetting SetPixelShader to NULL",
2519	"D3D9RenderSystem::unbindGpuProgram");
2520	}
2521	break;
2522	};
2523	RenderSystem::unbindGpuProgram(gptype);
2524	}
2525	//---------------------------------------------------------------------
2526	void D3D9RenderSystem::bindGpuProgramParameters(GpuProgramType gptype,
2527	GpuProgramParametersSharedPtr params)
2528	{
2529	HRESULT hr;
2530	unsigned int index;
2531	GpuProgramParameters::IntConstantIterator intIt = params->getIntConstantIterator();
2532	GpuProgramParameters::RealConstantIterator realIt = params->getRealConstantIterator();
2533
2534	switch(gptype)
2535	{
2536	case GPT_VERTEX_PROGRAM:
2537	mActiveVertexGpuProgramParameters = params;
2538	// Bind floats
2539	if (params->hasRealConstantParams())
2540	{
2541	// Iterate over params and set the relevant ones
2542	index = 0;
2543	while (realIt.hasMoreElements())
2544	{
2545	const GpuProgramParameters::RealConstantEntry* e = realIt.peekNextPtr();
2546	if (e->isSet)
2547	{
2548	if (FAILED(hr = mpD3DDevice->SetVertexShaderConstantF(
2549	index, e->val, 1)))
2550	{
2551	OGRE_EXCEPT(hr, "Unable to upload vertex shader float parameters",
2552	"D3D9RenderSystem::bindGpuProgramParameters");
2553	}
2554	}
2555	index++;
2556	realIt.moveNext();
2557	}
2558	}
2559	// Bind ints
2560	if (params->hasIntConstantParams())
2561	{
2562	// Iterate over params and set the relevant ones
2563	index = 0;
2564	while (intIt.hasMoreElements())
2565	{
2566	const GpuProgramParameters::IntConstantEntry* e = intIt.peekNextPtr();
2567	if (e->isSet)
2568	{
2569	if (FAILED(hr = mpD3DDevice->SetVertexShaderConstantI(
2570	index, e->val, 1)))
2571	{
2572	OGRE_EXCEPT(hr, "Unable to upload vertex shader float parameters",
2573	"D3D9RenderSystem::bindGpuProgramParameters");
2574	}
2575	}
2576	index++;
2577	intIt.moveNext();
2578	}
2579	}
2580	break;
2581	case GPT_FRAGMENT_PROGRAM:
2582	mActiveFragmentGpuProgramParameters = params;
2583	// Bind floats
2584	if (params->hasRealConstantParams())
2585	{
2586	// Iterate over params and set the relevant ones
2587	index = 0;
2588	while (realIt.hasMoreElements())
2589	{
2590	const GpuProgramParameters::RealConstantEntry* e = realIt.peekNextPtr();
2591	if (e->isSet)
2592	{
2593	/*
2594	// TEST
2595	LogManager::getSingleton().logMessage(
2596	" Set Constant " + StringConverter::toString(index) + " to float4(" +
2597	StringConverter::toString(e->val[0]) + ", " +
2598	StringConverter::toString(e->val[1]) + ", " +
2599	StringConverter::toString(e->val[2]) + ", " +
2600	StringConverter::toString(e->val[3]) + ")");
2601	*/
2602
2603	if (FAILED(hr = mpD3DDevice->SetPixelShaderConstantF(
2604	index, e->val, 1)))
2605	{
2606	OGRE_EXCEPT(hr, "Unable to upload pixel shader float parameters",
2607	"D3D9RenderSystem::bindGpuProgramParameters");
2608	}
2609	}
2610	index++;
2611	realIt.moveNext();
2612	}
2613	}
2614	// Bind ints
2615	if (params->hasIntConstantParams())
2616	{
2617	// Iterate over params and set the relevant ones
2618	index = 0;
2619	while (intIt.hasMoreElements())
2620	{
2621	const GpuProgramParameters::IntConstantEntry* e = intIt.peekNextPtr();
2622	if (e->isSet)
2623	{
2624	if (FAILED(hr = mpD3DDevice->SetPixelShaderConstantI(
2625	index, e->val, 1)))
2626	{
2627	OGRE_EXCEPT(hr, "Unable to upload pixel shader float parameters",
2628	"D3D9RenderSystem::bindGpuProgramParameters");
2629	}
2630	}
2631	index++;
2632	intIt.moveNext();
2633	}
2634	}
2635	break;
2636	};
2637	}
2638	//---------------------------------------------------------------------
2639	void D3D9RenderSystem::bindGpuProgramPassIterationParameters(GpuProgramType gptype)
2640	{
2641
2642	HRESULT hr;
2643	GpuProgramParameters::RealConstantEntry* realEntry;
2644
2645	switch(gptype)
2646	{
2647	case GPT_VERTEX_PROGRAM:
2648	realEntry = mActiveVertexGpuProgramParameters->getPassIterationEntry();
2649	if (realEntry)
2650	{
2651	if (FAILED(hr = mpD3DDevice->SetVertexShaderConstantF(
2652	mActiveVertexGpuProgramParameters->getPassIterationEntryIndex(), realEntry->val, 1)))
2653	{
2654	OGRE_EXCEPT(hr, "Unable to upload vertex shader multi pass parameters",
2655	"D3D9RenderSystem::bindGpuProgramMultiPassParameters");
2656	}
2657	}
2658	break;
2659
2660	case GPT_FRAGMENT_PROGRAM:
2661	realEntry = mActiveFragmentGpuProgramParameters->getPassIterationEntry();
2662	if (realEntry)
2663	{
2664	if (FAILED(hr = mpD3DDevice->SetPixelShaderConstantF(
2665	mActiveFragmentGpuProgramParameters->getPassIterationEntryIndex(), realEntry->val, 1)))
2666	{
2667	OGRE_EXCEPT(hr, "Unable to upload pixel shader multi pass parameters",
2668	"D3D9RenderSystem::bindGpuProgramMultiPassParameters");
2669	}
2670	}
2671	break;
2672
2673	}
2674	}
2675	//---------------------------------------------------------------------
2676	void D3D9RenderSystem::setClipPlanes(const PlaneList& clipPlanes)
2677	{
2678	size_t i;
2679	size_t numClipPlanes;
2680	float dx9ClipPlane[4];
2681	DWORD mask = 0;
2682	HRESULT hr;
2683
2684	numClipPlanes = clipPlanes.size();
2685	for (i = 0; i < numClipPlanes; ++i)
2686	{
2687	const Plane& plane = clipPlanes[i];
2688
2689	dx9ClipPlane[0] = plane.normal.x;
2690	dx9ClipPlane[1] = plane.normal.y;
2691	dx9ClipPlane[2] = plane.normal.z;
2692	dx9ClipPlane[3] = plane.d;
2693
2694	hr = mpD3DDevice->SetClipPlane(i, dx9ClipPlane);
2695	if (FAILED(hr))
2696	{
2697	OGRE_EXCEPT(hr, "Unable to set clip plane",
2698	"D3D9RenderSystem::setClipPlanes");
2699	}
2700
2701	mask \|= (1 << i);
2702	}
2703
2704	hr = __SetRenderState(D3DRS_CLIPPLANEENABLE, mask);
2705	if (FAILED(hr))
2706	{
2707	OGRE_EXCEPT(hr, "Unable to set render state for clip planes",
2708	"D3D9RenderSystem::setClipPlanes");
2709	}
2710	}
2711	//---------------------------------------------------------------------
2712	void D3D9RenderSystem::setScissorTest(bool enabled, size_t left, size_t top, size_t right,
2713	size_t bottom)
2714	{
2715	HRESULT hr;
2716	if (enabled)
2717	{
2718	if (FAILED(hr = __SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE)))
2719	{
2720	OGRE_EXCEPT(hr, "Unable to enable scissor rendering state; " + getErrorDescription(hr),
2721	"D3D9RenderSystem::setScissorTest");
2722	}
2723	RECT rect;
2724	rect.left = left;
2725	rect.top = top;
2726	rect.bottom = bottom;
2727	rect.right = right;
2728	if (FAILED(hr = mpD3DDevice->SetScissorRect(&rect)))
2729	{
2730	OGRE_EXCEPT(hr, "Unable to set scissor rectangle; " + getErrorDescription(hr),
2731	"D3D9RenderSystem::setScissorTest");
2732	}
2733	}
2734	else
2735	{
2736	if (FAILED(hr = __SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE)))
2737	{
2738	OGRE_EXCEPT(hr, "Unable to disable scissor rendering state; " + getErrorDescription(hr),
2739	"D3D9RenderSystem::setScissorTest");
2740	}
2741	}
2742	}
2743	//---------------------------------------------------------------------
2744	void D3D9RenderSystem::clearFrameBuffer(unsigned int buffers,
2745	const ColourValue& colour, Real depth, unsigned short stencil)
2746	{
2747	DWORD flags = 0;
2748	if (buffers & FBT_COLOUR)
2749	{
2750	flags \|= D3DCLEAR_TARGET;
2751	}
2752	if (buffers & FBT_DEPTH)
2753	{
2754	flags \|= D3DCLEAR_ZBUFFER;
2755	}
2756	// Only try to clear the stencil buffer if supported
2757	if (buffers & FBT_STENCIL && mCapabilities->hasCapability(RSC_HWSTENCIL))
2758	{
2759	flags \|= D3DCLEAR_STENCIL;
2760	}
2761	HRESULT hr;
2762	if( FAILED( hr = mpD3DDevice->Clear(
2763	0,
2764	NULL,
2765	flags,
2766	colour.getAsARGB(),
2767	depth,
2768	stencil ) ) )
2769	{
2770	String msg = DXGetErrorDescription9(hr);
2771	OGRE_EXCEPT( hr, "Error clearing frame buffer : "
2772	+ msg, "D3D9RenderSystem::clearFrameBuffer" );
2773	}
2774	}
2775	//---------------------------------------------------------------------
2776	void D3D9RenderSystem::_makeProjectionMatrix(Real left, Real right,
2777	Real bottom, Real top, Real nearPlane, Real farPlane, Matrix4& dest,
2778	bool forGpuProgram)
2779	{
2780	// Correct position for off-axis projection matrix
2781	if (!forGpuProgram)
2782	{
2783	Real offsetX = left + right;
2784	Real offsetY = top + bottom;
2785
2786	left -= offsetX;
2787	right -= offsetX;
2788	top -= offsetY;
2789	bottom -= offsetY;
2790	}
2791
2792	Real width = right - left;
2793	Real height = top - bottom;
2794	Real q, qn;
2795	if (farPlane == 0)
2796	{
2797	q = 1 - Frustum::INFINITE_FAR_PLANE_ADJUST;
2798	qn = nearPlane * (Frustum::INFINITE_FAR_PLANE_ADJUST - 1);
2799	}
2800	else
2801	{
2802	q = farPlane / ( farPlane - nearPlane );
2803	qn = -q * nearPlane;
2804	}
2805	dest = Matrix4::ZERO;
2806	dest[0][0] = 2 * nearPlane / width;
2807	dest[0][2] = (right+left) / width;
2808	dest[1][1] = 2 * nearPlane / height;
2809	dest[1][2] = (top+bottom) / height;
2810	if (forGpuProgram)
2811	{
2812	dest[2][2] = -q;
2813	dest[3][2] = -1.0f;
2814	}
2815	else
2816	{
2817	dest[2][2] = q;
2818	dest[3][2] = 1.0f;
2819	}
2820	dest[2][3] = qn;
2821	}
2822
2823	// ------------------------------------------------------------------
2824	void D3D9RenderSystem::setClipPlane (ushort index, Real A, Real B, Real C, Real D)
2825	{
2826	float plane[4] = { A, B, C, D };
2827	mpD3DDevice->SetClipPlane (index, plane);
2828	}
2829
2830	// ------------------------------------------------------------------
2831	void D3D9RenderSystem::enableClipPlane (ushort index, bool enable)
2832	{
2833	DWORD prev;
2834	mpD3DDevice->GetRenderState(D3DRS_CLIPPLANEENABLE, &prev);
2835	__SetRenderState(D3DRS_CLIPPLANEENABLE, prev \| (1 << index));
2836	}
2837	//---------------------------------------------------------------------
2838	HardwareOcclusionQuery* D3D9RenderSystem::createHardwareOcclusionQuery(void)
2839	{
2840	D3D9HardwareOcclusionQuery* ret = new D3D9HardwareOcclusionQuery (mpD3DDevice);
2841	mHwOcclusionQueries.push_back(ret);
2842	return ret;
2843	}
2844	//---------------------------------------------------------------------
2845	Real D3D9RenderSystem::getHorizontalTexelOffset(void)
2846	{
2847	// D3D considers the origin to be in the center of a pixel
2848	return -0.5f;
2849	}
2850	//---------------------------------------------------------------------
2851	Real D3D9RenderSystem::getVerticalTexelOffset(void)
2852	{
2853	// D3D considers the origin to be in the center of a pixel
2854	return -0.5f;
2855	}
2856	//---------------------------------------------------------------------
2857	void D3D9RenderSystem::_applyObliqueDepthProjection(Matrix4& matrix, const Plane& plane,
2858	bool forGpuProgram)
2859	{
2860	// Thanks to Eric Lenyel for posting this calculation at www.terathon.com
2861
2862	// Calculate the clip-space corner point opposite the clipping plane
2863	// as (sgn(clipPlane.x), sgn(clipPlane.y), 1, 1) and
2864	// transform it into camera space by multiplying it
2865	// by the inverse of the projection matrix
2866
2867	/* generalised version
2868	Vector4 q = matrix.inverse() *
2869	Vector4(Math::Sign(plane.normal.x), Math::Sign(plane.normal.y), 1.0f, 1.0f);
2870	*/
2871	Vector4 q;
2872	q.x = Math::Sign(plane.normal.x) / matrix[0][0];
2873	q.y = Math::Sign(plane.normal.y) / matrix[1][1];
2874	q.z = 1.0F;
2875	// flip the next bit from Lengyel since we're right-handed
2876	if (forGpuProgram)
2877	{
2878	q.w = (1.0F - matrix[2][2]) / matrix[2][3];
2879	}
2880	else
2881	{
2882	q.w = (1.0F + matrix[2][2]) / matrix[2][3];
2883	}
2884
2885	// Calculate the scaled plane vector
2886	Vector4 clipPlane4d(plane.normal.x, plane.normal.y, plane.normal.z, plane.d);
2887	Vector4 c = clipPlane4d * (1.0F / (clipPlane4d.dotProduct(q)));
2888
2889	// Replace the third row of the projection matrix
2890	matrix[2][0] = c.x;
2891	matrix[2][1] = c.y;
2892	// flip the next bit from Lengyel since we're right-handed
2893	if (forGpuProgram)
2894	{
2895	matrix[2][2] = c.z;
2896	}
2897	else
2898	{
2899	matrix[2][2] = -c.z;
2900	}
2901	matrix[2][3] = c.w;
2902	}
2903	//---------------------------------------------------------------------
2904	Real D3D9RenderSystem::getMinimumDepthInputValue(void)
2905	{
2906	// Range [0.0f, 1.0f]
2907	return 0.0f;
2908	}
2909	//---------------------------------------------------------------------
2910	Real D3D9RenderSystem::getMaximumDepthInputValue(void)
2911	{
2912	// Range [0.0f, 1.0f]
2913	// D3D inverts even identity view matrices, so maximum INPUT is -1.0
2914	return -1.0f;
2915	}
2916	//---------------------------------------------------------------------
2917	void D3D9RenderSystem::restoreLostDevice(void)
2918	{
2919	// Release all non-managed resources
2920
2921	// Cleanup depth stencils
2922	_cleanupDepthStencils();
2923
2924	// Set all texture units to nothing
2925	_disableTextureUnitsFrom(0);
2926
2927	// Unbind any vertex streams
2928	for (size_t i = 0; i < mLastVertexSourceCount; ++i)
2929	{
2930	mpD3DDevice->SetStreamSource(i, NULL, 0, 0);
2931	}
2932	mLastVertexSourceCount = 0;
2933
2934	// Release all automatic temporary buffers and free unused
2935	// temporary buffers, so we doesn't need to recreate them,
2936	// and they will reallocate on demand. This save a lot of
2937	// release/recreate of non-managed vertex buffers which
2938	// wasn't need at all.
2939	mHardwareBufferManager->_releaseBufferCopies(true);
2940
2941	// We have to deal with non-managed textures and vertex buffers
2942	// GPU programs don't have to be restored
2943	static_cast<D3D9TextureManager*>(mTextureManager)->releaseDefaultPoolResources();
2944	static_cast<D3D9HardwareBufferManager*>(mHardwareBufferManager)
2945	->releaseDefaultPoolResources();
2946
2947	// release additional swap chains (secondary windows)
2948	SecondaryWindowList::iterator sw;
2949	for (sw = mSecondaryWindows.begin(); sw != mSecondaryWindows.end(); ++sw)
2950	{
2951	(*sw)->destroyD3DResources();
2952	}
2953
2954	// Reset the device, using the primary window presentation params
2955	HRESULT hr = mpD3DDevice->Reset(
2956	mPrimaryWindow->getPresentationParameters());
2957
2958	if (hr == D3DERR_DEVICELOST)
2959	{
2960	// Don't continue
2961	return;
2962	}
2963	else if (FAILED(hr))
2964	{
2965	OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
2966	"Cannot reset device! " + getErrorDescription(hr),
2967	"D3D9RenderWindow::restoreLostDevice" );
2968	}
2969
2970	// will have lost basic states
2971	mBasicStatesInitialised = false;
2972	mVertexProgramBound = false;
2973	mFragmentProgramBound = false;
2974
2975
2976	// recreate additional swap chains
2977	for (sw = mSecondaryWindows.begin(); sw != mSecondaryWindows.end(); ++sw)
2978	{
2979	(*sw)->createD3DResources();
2980	}
2981
2982	// Recreate all non-managed resources
2983	static_cast<D3D9TextureManager*>(mTextureManager)
2984	->recreateDefaultPoolResources();
2985	static_cast<D3D9HardwareBufferManager*>(mHardwareBufferManager)
2986	->recreateDefaultPoolResources();
2987
2988	LogManager::getSingleton().logMessage("!!! Direct3D Device successfully restored.");
2989
2990	mDeviceLost = false;
2991
2992	fireEvent("DeviceRestored");
2993
2994	}
2995	//---------------------------------------------------------------------
2996	bool D3D9RenderSystem::isDeviceLost(void)
2997	{
2998	return mDeviceLost;
2999	}
3000	//---------------------------------------------------------------------
3001	void D3D9RenderSystem::_notifyDeviceLost(void)
3002	{
3003	LogManager::getSingleton().logMessage("!!! Direct3D Device Lost!");
3004	mDeviceLost = true;
3005	// will have lost basic states
3006	mBasicStatesInitialised = false;
3007
3008	fireEvent("DeviceLost");
3009	}
3010
3011	//---------------------------------------------------------------------
3012	// Formats to try, in decreasing order of preference
3013	D3DFORMAT ddDepthStencilFormats[]={
3014	D3DFMT_D24FS8,
3015	D3DFMT_D24S8,
3016	D3DFMT_D24X4S4,
3017	D3DFMT_D24X8,
3018	D3DFMT_D15S1,
3019	D3DFMT_D16,
3020	D3DFMT_D32
3021	};
3022	#define NDSFORMATS (sizeof(ddDepthStencilFormats)/sizeof(D3DFORMAT))
3023
3024	D3DFORMAT D3D9RenderSystem::_getDepthStencilFormatFor(D3DFORMAT fmt)
3025	{
3026	/// Check if result is cached
3027	DepthStencilHash::iterator i = mDepthStencilHash.find((unsigned int)fmt);
3028	if(i != mDepthStencilHash.end())
3029	return i->second;
3030	/// If not, probe with CheckDepthStencilMatch
3031	D3DFORMAT dsfmt = D3DFMT_UNKNOWN;
3032
3033	/// Get description of primary render target
3034	LPDIRECT3DSURFACE9 mSurface = mPrimaryWindow->getRenderSurface();
3035	D3DSURFACE_DESC srfDesc;
3036
3037	if(!FAILED(mSurface->GetDesc(&srfDesc)))
3038	{
3039	/// Probe all depth stencil formats
3040	/// Break on first one that matches
3041	for(size_t x=0; x<NDSFORMATS; ++x)
3042	{
3043	// Verify that the depth format exists
3044	if (mpD3D->CheckDeviceFormat(
3045	mActiveD3DDriver->getAdapterNumber(),
3046	D3DDEVTYPE_HAL,
3047	srfDesc.Format,
3048	D3DUSAGE_DEPTHSTENCIL,
3049	D3DRTYPE_SURFACE,
3050	ddDepthStencilFormats[x]) != D3D_OK)
3051	{
3052	continue;
3053	}
3054	// Verify that the depth format is compatible
3055	if(mpD3D->CheckDepthStencilMatch(
3056	mActiveD3DDriver->getAdapterNumber(),
3057	D3DDEVTYPE_HAL, srfDesc.Format,
3058	fmt, ddDepthStencilFormats[x]) == D3D_OK)
3059	{
3060	dsfmt = ddDepthStencilFormats[x];
3061	break;
3062	}
3063	}
3064	}
3065	/// Cache result
3066	mDepthStencilHash[(unsigned int)fmt] = dsfmt;
3067	return dsfmt;
3068	}
3069	IDirect3DSurface9* D3D9RenderSystem::_getDepthStencilFor(D3DFORMAT fmt, D3DMULTISAMPLE_TYPE multisample, size_t width, size_t height)
3070	{
3071	D3DFORMAT dsfmt = _getDepthStencilFormatFor(fmt);
3072	if(dsfmt == D3DFMT_UNKNOWN)
3073	return 0;
3074	IDirect3DSurface9 *surface = 0;
3075
3076	/// Check if result is cached
3077	ZBufferFormat zbfmt(dsfmt, multisample);
3078	ZBufferHash::iterator i = mZBufferHash.find(zbfmt);
3079	if(i != mZBufferHash.end())
3080	{
3081	/// Check if size is larger or equal
3082	if(i->second.width >= width && i->second.height >= height)
3083	{
3084	surface = i->second.surface;
3085	}
3086	else
3087	{
3088	/// If not, destroy current buffer
3089	i->second.surface->Release();
3090	mZBufferHash.erase(i);
3091	}
3092	}
3093	if(!surface)
3094	{
3095	/// If not, create the depthstencil surface
3096	HRESULT hr = mpD3DDevice->CreateDepthStencilSurface(
3097	width,
3098	height,
3099	dsfmt,
3100	multisample,
3101	NULL,
3102	TRUE, // discard true or false?
3103	&surface,
3104	NULL);
3105	if(FAILED(hr))
3106	{
3107	String msg = DXGetErrorDescription9(hr);
3108	OGRE_EXCEPT( hr, "Error CreateDepthStencilSurface : " + msg, "D3D9RenderSystem::_getDepthStencilFor" );
3109	}
3110	/// And cache it
3111	ZBufferRef zb;
3112	zb.surface = surface;
3113	zb.width = width;
3114	zb.height = height;
3115	mZBufferHash[zbfmt] = zb;
3116	}
3117	return surface;
3118	}
3119	void D3D9RenderSystem::_cleanupDepthStencils()
3120	{
3121	for(ZBufferHash::iterator i = mZBufferHash.begin(); i != mZBufferHash.end(); ++i)
3122	{
3123	/// Release buffer
3124	i->second.surface->Release();
3125	}
3126	mZBufferHash.clear();
3127	}
3128	}

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

Context Navigation

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

Download in other formats: