Context Navigation

OgreD3D9Texture.cpp @ 692

Revision 692, 37.0 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://www.ogre3d.org/
6
7	Copyright (c) 2000-2005 The OGRE Team
8	Also see acknowledgements in Readme.html
9
10	This program is free software; you can redistribute it and/or modify it under
11	the terms of the GNU Lesser General Public License as published by the Free Software
12	Foundation; either version 2 of the License, or (at your option) any later
13	version.
14
15	This program is distributed in the hope that it will be useful, but WITHOUT
16	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17	FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18
19	You should have received a copy of the GNU Lesser General Public License along with
20	this program; if not, write to the Free Software Foundation, Inc., 59 Temple
21	Place - Suite 330, Boston, MA 02111-1307, USA, or go to
22	http://www.gnu.org/copyleft/lesser.txt.
23	-----------------------------------------------------------------------------
24	*/
25	#include "OgreD3D9Texture.h"
26	#include "OgreD3D9HardwarePixelBuffer.h"
27	#include "OgreException.h"
28	#include "OgreLogManager.h"
29	#include "OgreStringConverter.h"
30	#include "OgreBitwise.h"
31	#include "OgreD3D9Mappings.h"
32
33	#include "OgreNoMemoryMacros.h"
34	#include <d3dx9.h>
35	#include <dxerr9.h>
36	#include "OgreMemoryMacros.h"
37
38	namespace Ogre
39	{
40	/****************************************************************************************/
41	D3D9Texture::D3D9Texture(ResourceManager* creator, const String& name,
42	ResourceHandle handle, const String& group, bool isManual,
43	ManualResourceLoader* loader, IDirect3DDevice9 *pD3DDevice)
44	:Texture(creator, name, handle, group, isManual, loader),
45	mpDev(pD3DDevice),
46	mpD3D(NULL),
47	mpNormTex(NULL),
48	mpCubeTex(NULL),
49	mpVolumeTex(NULL),
50	mpTex(NULL),
51	mDynamicTextures(false)
52	{
53	_initDevice();
54	}
55	/****************************************************************************************/
56	D3D9Texture::~D3D9Texture()
57	{
58	// have to call this here reather than in Resource destructor
59	// since calling virtual methods in base destructors causes crash
60	if (mIsLoaded)
61	{
62	unload();
63	}
64	else
65	{
66	freeInternalResources();
67	}
68	}
69	/****************************************************************************************/
70	void D3D9Texture::copyToTexture(TexturePtr& target)
71	{
72	// check if this & target are the same format and type
73	// blitting from or to cube textures is not supported yet
74	if (target->getUsage() != this->getUsage() \|\|
75	target->getTextureType() != this->getTextureType())
76	{
77	OGRE_EXCEPT( Exception::ERR_INVALIDPARAMS,
78	"Src. and dest. textures must be of same type and must have the same usage !!!",
79	"D3D9Texture::copyToTexture" );
80	}
81
82	HRESULT hr;
83	D3D9Texture *other;
84	// get the target
85	other = reinterpret_cast< D3D9Texture * >( target.get() );
86	// target rectangle (whole surface)
87	RECT dstRC = {0, 0, other->getWidth(), other->getHeight()};
88
89	// do it plain for normal texture
90	if (this->getTextureType() == TEX_TYPE_2D)
91	{
92	// get our source surface
93	IDirect3DSurface9 *pSrcSurface = 0;
94	if( FAILED( hr = mpNormTex->GetSurfaceLevel(0, &pSrcSurface) ) )
95	{
96	String msg = DXGetErrorDescription9(hr);
97	OGRE_EXCEPT( hr, "Couldn't blit : " + msg, "D3D9Texture::copyToTexture" );
98	}
99
100	// get our target surface
101	IDirect3DSurface9 *pDstSurface = 0;
102	IDirect3DTexture9 *pOthTex = other->getNormTexture();
103	if( FAILED( hr = pOthTex->GetSurfaceLevel(0, &pDstSurface) ) )
104	{
105	String msg = DXGetErrorDescription9(hr);
106	SAFE_RELEASE(pSrcSurface);
107	OGRE_EXCEPT( hr, "Couldn't blit : " + msg, "D3D9Texture::copyToTexture" );
108	}
109
110	// do the blit, it's called StretchRect in D3D9 :)
111	if( FAILED( hr = mpDev->StretchRect( pSrcSurface, NULL, pDstSurface, &dstRC, D3DTEXF_NONE) ) )
112	{
113	String msg = DXGetErrorDescription9(hr);
114	SAFE_RELEASE(pSrcSurface);
115	SAFE_RELEASE(pDstSurface);
116	OGRE_EXCEPT( hr, "Couldn't blit : " + msg, "D3D9Texture::copyToTexture" );
117	}
118
119	// release temp. surfaces
120	SAFE_RELEASE(pSrcSurface);
121	SAFE_RELEASE(pDstSurface);
122	}
123	else if (this->getTextureType() == TEX_TYPE_CUBE_MAP)
124	{
125	// get the target cube texture
126	IDirect3DCubeTexture9 *pOthTex = other->getCubeTexture();
127	// blit to 6 cube faces
128	for (size_t face = 0; face < 6; face++)
129	{
130	// get our source surface
131	IDirect3DSurface9 *pSrcSurface = 0;
132	if( FAILED( hr = mpCubeTex->GetCubeMapSurface((D3DCUBEMAP_FACES)face, 0, &pSrcSurface) ) )
133	{
134	String msg = DXGetErrorDescription9(hr);
135	OGRE_EXCEPT( hr, "Couldn't blit : " + msg, "D3D9Texture::copyToTexture" );
136	}
137
138	// get our target surface
139	IDirect3DSurface9 *pDstSurface = 0;
140	if( FAILED( hr = pOthTex->GetCubeMapSurface((D3DCUBEMAP_FACES)face, 0, &pDstSurface) ) )
141	{
142	String msg = DXGetErrorDescription9(hr);
143	SAFE_RELEASE(pSrcSurface);
144	OGRE_EXCEPT( hr, "Couldn't blit : " + msg, "D3D9Texture::copyToTexture" );
145	}
146
147	// do the blit, it's called StretchRect in D3D9 :)
148	if( FAILED( hr = mpDev->StretchRect( pSrcSurface, NULL, pDstSurface, &dstRC, D3DTEXF_NONE) ) )
149	{
150	String msg = DXGetErrorDescription9(hr);
151	SAFE_RELEASE(pSrcSurface);
152	SAFE_RELEASE(pDstSurface);
153	OGRE_EXCEPT( hr, "Couldn't blit : " + msg, "D3D9Texture::copyToTexture" );
154	}
155
156	// release temp. surfaces
157	SAFE_RELEASE(pSrcSurface);
158	SAFE_RELEASE(pDstSurface);
159	}
160	}
161	else
162	{
163	OGRE_EXCEPT( Exception::UNIMPLEMENTED_FEATURE,
164	"Copy to texture is implemented only for 2D and cube textures !!!",
165	"D3D9Texture::copyToTexture" );
166	}
167	}
168	/****************************************************************************************/
169	void D3D9Texture::loadImage( const Image &img )
170	{
171	// Use OGRE its own codecs
172	std::vector<const Image*> imagePtrs;
173	imagePtrs.push_back(&img);
174	_loadImages( imagePtrs );
175	}
176	/****************************************************************************************/
177	void D3D9Texture::loadImpl()
178	{
179	if (mUsage & TU_RENDERTARGET)
180	{
181	createInternalResources();
182	mIsLoaded = true;
183	return;
184	}
185
186	// load based on tex.type
187	switch (this->getTextureType())
188	{
189	case TEX_TYPE_1D:
190	case TEX_TYPE_2D:
191	this->_loadNormTex();
192	break;
193	case TEX_TYPE_3D:
194	this->_loadVolumeTex();
195	break;
196	case TEX_TYPE_CUBE_MAP:
197	this->_loadCubeTex();
198	break;
199	default:
200	OGRE_EXCEPT( Exception::ERR_INTERNAL_ERROR, "Unknown texture type", "D3D9Texture::loadImpl" );
201	}
202
203	}
204	/****************************************************************************************/
205	void D3D9Texture::freeInternalResourcesImpl()
206	{
207	SAFE_RELEASE(mpTex);
208	SAFE_RELEASE(mpNormTex);
209	SAFE_RELEASE(mpCubeTex);
210	SAFE_RELEASE(mpVolumeTex);
211	}
212	/****************************************************************************************/
213	void D3D9Texture::_loadCubeTex()
214	{
215	assert(this->getTextureType() == TEX_TYPE_CUBE_MAP);
216
217	// DDS load?
218	if (StringUtil::endsWith(getName(), ".dds"))
219	{
220	// find & load resource data
221	DataStreamPtr dstream =
222	ResourceGroupManager::getSingleton().openResource(
223	mName, mGroup, true, this);
224	MemoryDataStream stream( dstream );
225
226	HRESULT hr = D3DXCreateCubeTextureFromFileInMemory(
227	mpDev,
228	stream.getPtr(),
229	stream.size(),
230	&mpCubeTex);
231
232	if (FAILED(hr))
233	{
234	this->freeInternalResources();
235	OGRE_EXCEPT( hr, "Can't create cube texture", "D3D9Texture::_loadCubeTex" );
236	}
237
238	hr = mpCubeTex->QueryInterface(IID_IDirect3DBaseTexture9, (void **)&mpTex);
239
240	if (FAILED(hr))
241	{
242	this->freeInternalResources();
243	OGRE_EXCEPT( hr, "Can't get base texture", "D3D9Texture::_loadCubeTex" );
244	}
245
246	D3DSURFACE_DESC texDesc;
247	mpCubeTex->GetLevelDesc(0, &texDesc);
248	// set src and dest attributes to the same, we can't know
249	_setSrcAttributes(texDesc.Width, texDesc.Height, 1, D3D9Mappings::_getPF(texDesc.Format));
250	_setFinalAttributes(texDesc.Width, texDesc.Height, 1, D3D9Mappings::_getPF(texDesc.Format));
251	mIsLoaded = true;
252	mInternalResourcesCreated = true;
253	}
254	else
255	{
256	// Load from 6 separate files
257	// Use OGRE its own codecs
258	String baseName, ext;
259	size_t pos = mName.find_last_of(".");
260	baseName = mName.substr(0, pos);
261	ext = mName.substr(pos+1);
262	std::vector<Image> images(6);
263	std::vector<const Image*> imagePtrs;
264	static const String suffixes[6] = {"_rt", "_lf", "_up", "_dn", "_fr", "_bk"};
265
266	for(size_t i = 0; i < 6; i++)
267	{
268	String fullName = baseName + suffixes[i] + "." + ext;
269
270	// find & load resource data intro stream to allow resource
271	// group changes if required
272	DataStreamPtr dstream =
273	ResourceGroupManager::getSingleton().openResource(
274	fullName, mGroup, true, this);
275
276	images[i].load(dstream, ext);
277
278	imagePtrs.push_back(&images[i]);
279	}
280
281	_loadImages( imagePtrs );
282	}
283	}
284	/****************************************************************************************/
285	void D3D9Texture::_loadVolumeTex()
286	{
287	assert(this->getTextureType() == TEX_TYPE_3D);
288	// DDS load?
289	if (StringUtil::endsWith(getName(), ".dds"))
290	{
291	// find & load resource data
292	DataStreamPtr dstream =
293	ResourceGroupManager::getSingleton().openResource(
294	mName, mGroup, true, this);
295	MemoryDataStream stream(dstream);
296
297	HRESULT hr = D3DXCreateVolumeTextureFromFileInMemory(
298	mpDev,
299	stream.getPtr(),
300	stream.size(),
301	&mpVolumeTex);
302
303	if (FAILED(hr))
304	{
305	OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
306	"Unable to load volume texture from " + this->getName(),
307	"D3D9Texture::_loadVolumeTex");
308	}
309
310	hr = mpVolumeTex->QueryInterface(IID_IDirect3DBaseTexture9, (void **)&mpTex);
311
312	if (FAILED(hr))
313	{
314	this->freeInternalResources();
315	OGRE_EXCEPT( hr, "Can't get base texture", "D3D9Texture::_loadVolumeTex" );
316	}
317
318	D3DVOLUME_DESC texDesc;
319	hr = mpVolumeTex->GetLevelDesc(0, &texDesc);
320
321	// set src and dest attributes to the same, we can't know
322	_setSrcAttributes(texDesc.Width, texDesc.Height, texDesc.Depth, D3D9Mappings::_getPF(texDesc.Format));
323	_setFinalAttributes(texDesc.Width, texDesc.Height, texDesc.Depth, D3D9Mappings::_getPF(texDesc.Format));
324	mIsLoaded = true;
325	mInternalResourcesCreated = true;
326	}
327	else
328	{
329	Image img;
330	// find & load resource data intro stream to allow resource
331	// group changes if required
332	DataStreamPtr dstream =
333	ResourceGroupManager::getSingleton().openResource(
334	mName, mGroup, true, this);
335	size_t pos = mName.find_last_of(".");
336	String ext = mName.substr(pos+1);
337
338	img.load(dstream, ext);
339	loadImage(img);
340	}
341	}
342	/****************************************************************************************/
343	void D3D9Texture::_loadNormTex()
344	{
345	assert(this->getTextureType() == TEX_TYPE_1D \|\| this->getTextureType() == TEX_TYPE_2D);
346	// DDS load?
347	if (StringUtil::endsWith(getName(), ".dds"))
348	{
349	// Use D3DX
350	// find & load resource data
351	DataStreamPtr dstream =
352	ResourceGroupManager::getSingleton().openResource(
353	mName, mGroup, true, this);
354	MemoryDataStream stream(dstream);
355
356	HRESULT hr = D3DXCreateTextureFromFileInMemory(
357	mpDev,
358	stream.getPtr(),
359	stream.size(),
360	&mpNormTex);
361
362	if (FAILED(hr))
363	{
364	OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
365	"Unable to load texture from " + this->getName(),
366	"D3D9Texture::_loadNormTex");
367	}
368
369	hr = mpNormTex->QueryInterface(IID_IDirect3DBaseTexture9, (void **)&mpTex);
370
371	if (FAILED(hr))
372	{
373	this->freeInternalResources();
374	OGRE_EXCEPT( hr, "Can't get base texture", "D3D9Texture::_loadNormTex" );
375	}
376
377	D3DSURFACE_DESC texDesc;
378	mpNormTex->GetLevelDesc(0, &texDesc);
379	// set src and dest attributes to the same, we can't know
380	_setSrcAttributes(texDesc.Width, texDesc.Height, 1, D3D9Mappings::_getPF(texDesc.Format));
381	_setFinalAttributes(texDesc.Width, texDesc.Height, 1, D3D9Mappings::_getPF(texDesc.Format));
382	mIsLoaded = true;
383	mInternalResourcesCreated = true;
384	}
385	else
386	{
387	Image img;
388	// find & load resource data intro stream to allow resource
389	// group changes if required
390	DataStreamPtr dstream =
391	ResourceGroupManager::getSingleton().openResource(
392	mName, mGroup, true, this);
393
394	size_t pos = mName.find_last_of(".");
395	String ext = mName.substr(pos+1);
396
397	img.load(dstream, ext);
398	loadImage(img);
399	}
400	}
401	/****************************************************************************************/
402	void D3D9Texture::createInternalResourcesImpl(void)
403	{
404	// If mSrcWidth and mSrcHeight are zero, the requested extents have probably been set
405	// through setWidth and setHeight, which set mWidth and mHeight. Take those values.
406	if(mSrcWidth == 0 \|\| mSrcHeight == 0) {
407	mSrcWidth = mWidth;
408	mSrcHeight = mHeight;
409	}
410
411	// Determine D3D pool to use
412	// Use managed unless we're a render target or user has asked for
413	// a dynamic texture
414	if ((mUsage & TU_RENDERTARGET) \|\|
415	(mUsage & TU_DYNAMIC))
416	{
417	mD3DPool = D3DPOOL_DEFAULT;
418	}
419	else
420	{
421	mD3DPool = D3DPOOL_MANAGED;
422	}
423	// load based on tex.type
424	switch (this->getTextureType())
425	{
426	case TEX_TYPE_1D:
427	case TEX_TYPE_2D:
428	this->_createNormTex();
429	break;
430	case TEX_TYPE_CUBE_MAP:
431	this->_createCubeTex();
432	break;
433	case TEX_TYPE_3D:
434	this->_createVolumeTex();
435	break;
436	default:
437	this->freeInternalResources();
438	OGRE_EXCEPT( Exception::ERR_INTERNAL_ERROR, "Unknown texture type", "D3D9Texture::createInternalResources" );
439	}
440	}
441	/****************************************************************************************/
442	void D3D9Texture::_createNormTex()
443	{
444	// we must have those defined here
445	assert(mSrcWidth > 0 \|\| mSrcHeight > 0);
446
447	// determine wich D3D9 pixel format we'll use
448	HRESULT hr;
449	D3DFORMAT d3dPF = this->_chooseD3DFormat();
450	// let's D3DX check the corrected pixel format
451	hr = D3DXCheckTextureRequirements(mpDev, NULL, NULL, NULL, 0, &d3dPF, mD3DPool);
452
453	// Use D3DX to help us create the texture, this way it can adjust any relevant sizes
454	DWORD usage = (mUsage & TU_RENDERTARGET) ? D3DUSAGE_RENDERTARGET : 0;
455	UINT numMips = mNumRequestedMipmaps + 1;
456	// Check dynamic textures
457	if (mUsage & TU_DYNAMIC)
458	{
459	if (_canUseDynamicTextures(usage, D3DRTYPE_TEXTURE, d3dPF))
460	{
461	usage \|= D3DUSAGE_DYNAMIC;
462	mDynamicTextures = true;
463	}
464	else
465	{
466	mDynamicTextures = false;
467	}
468	}
469	// check if mip maps are supported on hardware
470	mMipmapsHardwareGenerated = false;
471	if (mDevCaps.TextureCaps & D3DPTEXTURECAPS_MIPMAP)
472	{
473	if (mUsage & TU_AUTOMIPMAP && mNumRequestedMipmaps != 0)
474	{
475	// use auto.gen. if available, and if desired
476	mMipmapsHardwareGenerated = this->_canAutoGenMipmaps(usage, D3DRTYPE_TEXTURE, d3dPF);
477	if (mMipmapsHardwareGenerated)
478	{
479	usage \|= D3DUSAGE_AUTOGENMIPMAP;
480	numMips = 0;
481	}
482	}
483	}
484	else
485	{
486	// no mip map support for this kind of textures :(
487	mNumMipmaps = 0;
488	numMips = 1;
489	}
490
491	// create the texture
492	hr = D3DXCreateTexture(
493	mpDev, // device
494	mSrcWidth, // width
495	mSrcHeight, // height
496	numMips, // number of mip map levels
497	usage, // usage
498	d3dPF, // pixel format
499	mD3DPool,
500	&mpNormTex); // data pointer
501	// check result and except if failed
502	if (FAILED(hr))
503	{
504	this->freeInternalResources();
505	OGRE_EXCEPT( hr, "Error creating texture", "D3D9Texture::_createNormTex" );
506	}
507
508	// set the base texture we'll use in the render system
509	hr = mpNormTex->QueryInterface(IID_IDirect3DBaseTexture9, (void **)&mpTex);
510	if (FAILED(hr))
511	{
512	this->freeInternalResources();
513	OGRE_EXCEPT( hr, "Can't get base texture", "D3D9Texture::_createNormTex" );
514	}
515
516	// set final tex. attributes from tex. description
517	// they may differ from the source image !!!
518	D3DSURFACE_DESC desc;
519	hr = mpNormTex->GetLevelDesc(0, &desc);
520	if (FAILED(hr))
521	{
522	this->freeInternalResources();
523	OGRE_EXCEPT( hr, "Can't get texture description", "D3D9Texture::_createNormTex" );
524	}
525	this->_setFinalAttributes(desc.Width, desc.Height, 1, D3D9Mappings::_getPF(desc.Format));
526
527	// Set best filter type
528	if(mMipmapsHardwareGenerated)
529	{
530	hr = mpTex->SetAutoGenFilterType(_getBestFilterMethod());
531	if(FAILED(hr))
532	{
533	OGRE_EXCEPT( hr, "Could not set best autogen filter type", "D3D9Texture::_createNormTex" );
534	}
535	}
536	}
537	/****************************************************************************************/
538	void D3D9Texture::_createCubeTex()
539	{
540	// we must have those defined here
541	assert(mSrcWidth > 0 \|\| mSrcHeight > 0);
542
543	// determine wich D3D9 pixel format we'll use
544	HRESULT hr;
545	D3DFORMAT d3dPF = this->_chooseD3DFormat();
546	// let's D3DX check the corrected pixel format
547	hr = D3DXCheckCubeTextureRequirements(mpDev, NULL, NULL, 0, &d3dPF, mD3DPool);
548
549	// Use D3DX to help us create the texture, this way it can adjust any relevant sizes
550	DWORD usage = (mUsage & TU_RENDERTARGET) ? D3DUSAGE_RENDERTARGET : 0;
551	UINT numMips = mNumRequestedMipmaps + 1;
552	// Check dynamic textures
553	if (mUsage & TU_DYNAMIC)
554	{
555	if (_canUseDynamicTextures(usage, D3DRTYPE_CUBETEXTURE, d3dPF))
556	{
557	usage \|= D3DUSAGE_DYNAMIC;
558	mDynamicTextures = true;
559	}
560	else
561	{
562	mDynamicTextures = false;
563	}
564	}
565	// check if mip map cube textures are supported
566	mMipmapsHardwareGenerated = false;
567	if (mDevCaps.TextureCaps & D3DPTEXTURECAPS_MIPCUBEMAP)
568	{
569	if (mUsage & TU_AUTOMIPMAP && mNumRequestedMipmaps != 0)
570	{
571	// use auto.gen. if available
572	mMipmapsHardwareGenerated = this->_canAutoGenMipmaps(usage, D3DRTYPE_CUBETEXTURE, d3dPF);
573	if (mMipmapsHardwareGenerated)
574	{
575	usage \|= D3DUSAGE_AUTOGENMIPMAP;
576	numMips = 0;
577	}
578	}
579	}
580	else
581	{
582	// no mip map support for this kind of textures :(
583	mNumMipmaps = 0;
584	numMips = 1;
585	}
586
587	// create the texture
588	hr = D3DXCreateCubeTexture(
589	mpDev, // device
590	mSrcWidth, // dimension
591	numMips, // number of mip map levels
592	usage, // usage
593	d3dPF, // pixel format
594	mD3DPool,
595	&mpCubeTex); // data pointer
596	// check result and except if failed
597	if (FAILED(hr))
598	{
599	this->freeInternalResources();
600	OGRE_EXCEPT( hr, "Error creating texture", "D3D9Texture::_createCubeTex" );
601	}
602
603	// set the base texture we'll use in the render system
604	hr = mpCubeTex->QueryInterface(IID_IDirect3DBaseTexture9, (void **)&mpTex);
605	if (FAILED(hr))
606	{
607	this->freeInternalResources();
608	OGRE_EXCEPT( hr, "Can't get base texture", "D3D9Texture::_createCubeTex" );
609	}
610
611	// set final tex. attributes from tex. description
612	// they may differ from the source image !!!
613	D3DSURFACE_DESC desc;
614	hr = mpCubeTex->GetLevelDesc(0, &desc);
615	if (FAILED(hr))
616	{
617	this->freeInternalResources();
618	OGRE_EXCEPT( hr, "Can't get texture description", "D3D9Texture::_createCubeTex" );
619	}
620	this->_setFinalAttributes(desc.Width, desc.Height, 1, D3D9Mappings::_getPF(desc.Format));
621
622	// Set best filter type
623	if(mMipmapsHardwareGenerated)
624	{
625	hr = mpTex->SetAutoGenFilterType(_getBestFilterMethod());
626	if(FAILED(hr))
627	{
628	OGRE_EXCEPT( hr, "Could not set best autogen filter type", "D3D9Texture::_createCubeTex" );
629	}
630	}
631	}
632	/****************************************************************************************/
633	void D3D9Texture::_createVolumeTex()
634	{
635	// we must have those defined here
636	assert(mWidth > 0 && mHeight > 0 && mDepth>0);
637
638	// determine wich D3D9 pixel format we'll use
639	HRESULT hr;
640	D3DFORMAT d3dPF = this->_chooseD3DFormat();
641	// let's D3DX check the corrected pixel format
642	hr = D3DXCheckVolumeTextureRequirements(mpDev, NULL, NULL, NULL, NULL, 0, &d3dPF, mD3DPool);
643
644	// Use D3DX to help us create the texture, this way it can adjust any relevant sizes
645	DWORD usage = (mUsage & TU_RENDERTARGET) ? D3DUSAGE_RENDERTARGET : 0;
646	UINT numMips = mNumRequestedMipmaps + 1;
647	// Check dynamic textures
648	if (mUsage & TU_DYNAMIC)
649	{
650	if (_canUseDynamicTextures(usage, D3DRTYPE_VOLUMETEXTURE, d3dPF))
651	{
652	usage \|= D3DUSAGE_DYNAMIC;
653	mDynamicTextures = true;
654	}
655	else
656	{
657	mDynamicTextures = false;
658	}
659	}
660	// check if mip map volume textures are supported
661	mMipmapsHardwareGenerated = false;
662	if (mDevCaps.TextureCaps & D3DPTEXTURECAPS_MIPVOLUMEMAP)
663	{
664	if (mUsage & TU_AUTOMIPMAP && mNumRequestedMipmaps != 0)
665	{
666	// use auto.gen. if available
667	mMipmapsHardwareGenerated = this->_canAutoGenMipmaps(usage, D3DRTYPE_VOLUMETEXTURE, d3dPF);
668	if (mMipmapsHardwareGenerated)
669	{
670	usage \|= D3DUSAGE_AUTOGENMIPMAP;
671	numMips = 0;
672	}
673	}
674	}
675	else
676	{
677	// no mip map support for this kind of textures :(
678	mNumMipmaps = 0;
679	numMips = 1;
680	}
681
682	// create the texture
683	hr = D3DXCreateVolumeTexture(
684	mpDev, // device
685	mWidth, // dimension
686	mHeight,
687	mDepth,
688	numMips, // number of mip map levels
689	usage, // usage
690	d3dPF, // pixel format
691	mD3DPool,
692	&mpVolumeTex); // data pointer
693	// check result and except if failed
694	if (FAILED(hr))
695	{
696	this->freeInternalResources();
697	OGRE_EXCEPT( hr, "Error creating texture", "D3D9Texture::_createVolumeTex" );
698	}
699
700	// set the base texture we'll use in the render system
701	hr = mpVolumeTex->QueryInterface(IID_IDirect3DBaseTexture9, (void **)&mpTex);
702	if (FAILED(hr))
703	{
704	this->freeInternalResources();
705	OGRE_EXCEPT( hr, "Can't get base texture", "D3D9Texture::_createVolumeTex" );
706	}
707
708	// set final tex. attributes from tex. description
709	// they may differ from the source image !!!
710	D3DVOLUME_DESC desc;
711	hr = mpVolumeTex->GetLevelDesc(0, &desc);
712	if (FAILED(hr))
713	{
714	this->freeInternalResources();
715	OGRE_EXCEPT( hr, "Can't get texture description", "D3D9Texture::_createVolumeTex" );
716	}
717	this->_setFinalAttributes(desc.Width, desc.Height, desc.Depth, D3D9Mappings::_getPF(desc.Format));
718
719	// Set best filter type
720	if(mMipmapsHardwareGenerated)
721	{
722	hr = mpTex->SetAutoGenFilterType(_getBestFilterMethod());
723	if(FAILED(hr))
724	{
725	OGRE_EXCEPT( hr, "Could not set best autogen filter type", "D3D9Texture::_createCubeTex" );
726	}
727	}
728	}
729	/****************************************************************************************/
730	void D3D9Texture::_initDevice(void)
731	{
732	assert(mpDev);
733	HRESULT hr;
734
735	// get device caps
736	hr = mpDev->GetDeviceCaps(&mDevCaps);
737	if (FAILED(hr))
738	OGRE_EXCEPT( Exception::ERR_INTERNAL_ERROR, "Can't get device description", "D3D9Texture::_setDevice" );
739
740	// get D3D pointer
741	hr = mpDev->GetDirect3D(&mpD3D);
742	// decrement reference count
743	mpD3D->Release();
744	if (FAILED(hr))
745	OGRE_EXCEPT( hr, "Failed to get D3D9 pointer", "D3D9Texture::_setDevice" );
746
747	// get our device creation parameters
748	hr = mpDev->GetCreationParameters(&mDevCreParams);
749	if (FAILED(hr))
750	OGRE_EXCEPT( hr, "Failed to get D3D9 device creation parameters", "D3D9Texture::_setDevice" );
751
752	// get our back buffer pixel format
753	IDirect3DSurface9 *pSrf;
754	D3DSURFACE_DESC srfDesc;
755	hr = mpDev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pSrf);
756	// decrement reference count
757	pSrf->Release();
758	if (FAILED(hr))
759	OGRE_EXCEPT( hr, "Failed to get D3D9 device pixel format", "D3D9Texture::_setDevice" );
760
761	hr = pSrf->GetDesc(&srfDesc);
762	if (FAILED(hr))
763	{
764	OGRE_EXCEPT( hr, "Failed to get D3D9 device pixel format", "D3D9Texture::_setDevice" );
765	}
766
767	mBBPixelFormat = srfDesc.Format;
768	}
769	/****************************************************************************************/
770	void D3D9Texture::_setFinalAttributes(unsigned long width, unsigned long height,
771	unsigned long depth, PixelFormat format)
772	{
773	// set target texture attributes
774	mHeight = height;
775	mWidth = width;
776	mDepth = depth;
777	mFormat = format;
778
779	// Update size (the final size, not including temp space)
780	// this is needed in Resource class
781	unsigned short bytesPerPixel = mFinalBpp >> 3;
782	if( !mHasAlpha && mFinalBpp == 32 )
783	bytesPerPixel--;
784	mSize = mWidth * mHeight * mDepth * bytesPerPixel
785	* (mTextureType == TEX_TYPE_CUBE_MAP)? 6 : 1;
786
787	// say to the world what we are doing
788	if (mWidth != mSrcWidth \|\|
789	mHeight != mSrcHeight)
790	{
791	LogManager::getSingleton().logMessage("D3D9 : ***** Dimensions altered by the render system");
792	LogManager::getSingleton().logMessage("D3D9 : ***** Source image dimensions : " + StringConverter::toString(mSrcWidth) + "x" + StringConverter::toString(mSrcHeight));
793	LogManager::getSingleton().logMessage("D3D9 : ***** Texture dimensions : " + StringConverter::toString(mWidth) + "x" + StringConverter::toString(mHeight));
794	}
795
796	// Create list of subsurfaces for getBuffer()
797	_createSurfaceList();
798	}
799	/****************************************************************************************/
800	void D3D9Texture::_setSrcAttributes(unsigned long width, unsigned long height,
801	unsigned long depth, PixelFormat format)
802	{
803	// set source image attributes
804	mSrcWidth = width;
805	mSrcHeight = height;
806	mSrcBpp = PixelUtil::getNumElemBits(format);
807	mHasAlpha = PixelUtil::getFlags(format) & PFF_HASALPHA;
808	// say to the world what we are doing
809	switch (this->getTextureType())
810	{
811	case TEX_TYPE_1D:
812	if (mUsage & TU_RENDERTARGET)
813	LogManager::getSingleton().logMessage("D3D9 : Creating 1D RenderTarget, name : '" + this->getName() + "' with " + StringConverter::toString(mNumMipmaps) + " mip map levels");
814	else
815	LogManager::getSingleton().logMessage("D3D9 : Loading 1D Texture, image name : '" + this->getName() + "' with " + StringConverter::toString(mNumMipmaps) + " mip map levels");
816	break;
817	case TEX_TYPE_2D:
818	if (mUsage & TU_RENDERTARGET)
819	LogManager::getSingleton().logMessage("D3D9 : Creating 2D RenderTarget, name : '" + this->getName() + "' with " + StringConverter::toString(mNumMipmaps) + " mip map levels");
820	else
821	LogManager::getSingleton().logMessage("D3D9 : Loading 2D Texture, image name : '" + this->getName() + "' with " + StringConverter::toString(mNumMipmaps) + " mip map levels");
822	break;
823	case TEX_TYPE_3D:
824	if (mUsage & TU_RENDERTARGET)
825	LogManager::getSingleton().logMessage("D3D9 : Creating 3D RenderTarget, name : '" + this->getName() + "' with " + StringConverter::toString(mNumMipmaps) + " mip map levels");
826	else
827	LogManager::getSingleton().logMessage("D3D9 : Loading 3D Texture, image name : '" + this->getName() + "' with " + StringConverter::toString(mNumMipmaps) + " mip map levels");
828	break;
829	case TEX_TYPE_CUBE_MAP:
830	if (mUsage & TU_RENDERTARGET)
831	LogManager::getSingleton().logMessage("D3D9 : Creating Cube map RenderTarget, name : '" + this->getName() + "' with " + StringConverter::toString(mNumMipmaps) + " mip map levels");
832	else
833	LogManager::getSingleton().logMessage("D3D9 : Loading Cube Texture, base image name : '" + this->getName() + "' with " + StringConverter::toString(mNumMipmaps) + " mip map levels");
834	break;
835	default:
836	this->freeInternalResources();
837	OGRE_EXCEPT( Exception::ERR_INTERNAL_ERROR, "Unknown texture type", "D3D9Texture::_setSrcAttributes" );
838	}
839	}
840	/****************************************************************************************/
841	D3DTEXTUREFILTERTYPE D3D9Texture::_getBestFilterMethod()
842	{
843	// those MUST be initialized !!!
844	assert(mpDev);
845	assert(mpD3D);
846	assert(mpTex);
847
848	DWORD filterCaps = 0;
849	// Minification filter is used for mipmap generation
850	// Pick the best one supported for this tex type
851	switch (this->getTextureType())
852	{
853	case TEX_TYPE_1D: // Same as 2D
854	case TEX_TYPE_2D: filterCaps = mDevCaps.TextureFilterCaps; break;
855	case TEX_TYPE_3D: filterCaps = mDevCaps.VolumeTextureFilterCaps; break;
856	case TEX_TYPE_CUBE_MAP: filterCaps = mDevCaps.CubeTextureFilterCaps; break;
857	}
858	if(filterCaps & D3DPTFILTERCAPS_MINFGAUSSIANQUAD)
859	return D3DTEXF_GAUSSIANQUAD;
860
861	if(filterCaps & D3DPTFILTERCAPS_MINFPYRAMIDALQUAD)
862	return D3DTEXF_PYRAMIDALQUAD;
863
864	if(filterCaps & D3DPTFILTERCAPS_MINFANISOTROPIC)
865	return D3DTEXF_ANISOTROPIC;
866
867	if(filterCaps & D3DPTFILTERCAPS_MINFLINEAR)
868	return D3DTEXF_LINEAR;
869
870	if(filterCaps & D3DPTFILTERCAPS_MINFPOINT)
871	return D3DTEXF_POINT;
872
873	return D3DTEXF_POINT;
874	}
875	/****************************************************************************************/
876	bool D3D9Texture::_canUseDynamicTextures(DWORD srcUsage, D3DRESOURCETYPE srcType, D3DFORMAT srcFormat)
877	{
878	// those MUST be initialized !!!
879	assert(mpDev);
880	assert(mpD3D);
881
882	// Check for dynamic texture support
883	HRESULT hr;
884	// check for auto gen. mip maps support
885	hr = mpD3D->CheckDeviceFormat(
886	mDevCreParams.AdapterOrdinal,
887	mDevCreParams.DeviceType,
888	mBBPixelFormat,
889	srcUsage \| D3DUSAGE_DYNAMIC,
890	srcType,
891	srcFormat);
892	if (hr == D3D_OK)
893	return true;
894	else
895	return false;
896	}
897	/****************************************************************************************/
898	bool D3D9Texture::_canAutoGenMipmaps(DWORD srcUsage, D3DRESOURCETYPE srcType, D3DFORMAT srcFormat)
899	{
900	// those MUST be initialized !!!
901	assert(mpDev);
902	assert(mpD3D);
903
904	// Hacky override - many (all?) cards seem to not be able to autogen on
905	// textures which are not a power of two
906	// Can we even mipmap on 3D textures? Well
907	if ((mWidth & mWidth-1) \|\| (mHeight & mHeight-1) \|\| (mDepth & mDepth-1))
908	return false;
909
910	if (mDevCaps.Caps2 & D3DCAPS2_CANAUTOGENMIPMAP)
911	{
912	HRESULT hr;
913	// check for auto gen. mip maps support
914	hr = mpD3D->CheckDeviceFormat(
915	mDevCreParams.AdapterOrdinal,
916	mDevCreParams.DeviceType,
917	mBBPixelFormat,
918	srcUsage \| D3DUSAGE_AUTOGENMIPMAP,
919	srcType,
920	srcFormat);
921	// this HR could a SUCCES
922	// but mip maps will not be generated
923	if (hr == D3D_OK)
924	return true;
925	else
926	return false;
927	}
928	else
929	return false;
930	}
931	/****************************************************************************************/
932	D3DFORMAT D3D9Texture::_chooseD3DFormat()
933	{
934	// Choose frame buffer pixel format in case PF_UNKNOWN was requested
935	if(mFormat == PF_UNKNOWN)
936	return mBBPixelFormat;
937	// Choose closest supported D3D format as a D3D format
938	return D3D9Mappings::_getPF(D3D9Mappings::_getClosestSupportedPF(mFormat));
939
940	}
941	/****************************************************************************************/
942	// Macro to hide ugly cast
943	#define GETLEVEL(face,mip) \
944	static_cast<D3D9HardwarePixelBuffer>(mSurfaceList[face(mNumMipmaps+1)+mip].get())
945	void D3D9Texture::_createSurfaceList(void)
946	{
947	IDirect3DSurface9 *surface;
948	IDirect3DVolume9 *volume;
949	D3D9HardwarePixelBuffer *buffer;
950	size_t mip, face;
951	assert(mpTex);
952	// Make sure number of mips is right
953	mNumMipmaps = mpTex->GetLevelCount() - 1;
954	// Need to know static / dynamic
955	unsigned int bufusage;
956	if ((mUsage & TU_DYNAMIC) && mDynamicTextures)
957	{
958	bufusage = HardwareBuffer::HBU_DYNAMIC;
959	}
960	else
961	{
962	bufusage = HardwareBuffer::HBU_STATIC;
963	}
964	if (mUsage & TU_RENDERTARGET)
965	{
966	bufusage \|= TU_RENDERTARGET;
967	}
968
969	bool updateOldList = mSurfaceList.size() == (getNumFaces() * (mNumMipmaps + 1));
970	if(!updateOldList)
971	{
972	// Create new list of surfaces
973	mSurfaceList.clear();
974	for(size_t face=0; face<getNumFaces(); ++face)
975	{
976	for(size_t mip=0; mip<=mNumMipmaps; ++mip)
977	{
978	buffer = new D3D9HardwarePixelBuffer((HardwareBuffer::Usage)bufusage);
979	mSurfaceList.push_back(
980	HardwarePixelBufferSharedPtr(buffer)
981	);
982	}
983	}
984	}
985
986	switch(getTextureType()) {
987	case TEX_TYPE_2D:
988	case TEX_TYPE_1D:
989	assert(mpNormTex);
990	// For all mipmaps, store surfaces as HardwarePixelBufferSharedPtr
991	for(mip=0; mip<=mNumMipmaps; ++mip)
992	{
993	if(mpNormTex->GetSurfaceLevel(mip, &surface) != D3D_OK)
994	OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Get surface level failed",
995	"D3D9Texture::_createSurfaceList");
996	// decrement reference count, the GetSurfaceLevel call increments this
997	// this is safe because the texture keeps a reference as well
998	surface->Release();
999
1000	GETLEVEL(0, mip)->bind(mpDev, surface, updateOldList);
1001	}
1002	break;
1003	case TEX_TYPE_CUBE_MAP:
1004	assert(mpCubeTex);
1005	// For all faces and mipmaps, store surfaces as HardwarePixelBufferSharedPtr
1006	for(face=0; face<6; ++face)
1007	{
1008	for(mip=0; mip<=mNumMipmaps; ++mip)
1009	{
1010	if(mpCubeTex->GetCubeMapSurface((D3DCUBEMAP_FACES)face, mip, &surface) != D3D_OK)
1011	OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Get cubemap surface failed",
1012	"D3D9Texture::getBuffer");
1013	// decrement reference count, the GetSurfaceLevel call increments this
1014	// this is safe because the texture keeps a reference as well
1015	surface->Release();
1016
1017	GETLEVEL(face, mip)->bind(mpDev, surface, updateOldList);
1018	}
1019	}
1020	break;
1021	case TEX_TYPE_3D:
1022	assert(mpVolumeTex);
1023	// For all mipmaps, store surfaces as HardwarePixelBufferSharedPtr
1024	for(mip=0; mip<=mNumMipmaps; ++mip)
1025	{
1026	if(mpVolumeTex->GetVolumeLevel(mip, &volume) != D3D_OK)
1027	OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Get volume level failed",
1028	"D3D9Texture::getBuffer");
1029	// decrement reference count, the GetSurfaceLevel call increments this
1030	// this is safe because the texture keeps a reference as well
1031	volume->Release();
1032
1033	GETLEVEL(0, mip)->bind(mpDev, volume, updateOldList);
1034	}
1035	break;
1036	};
1037
1038	// Set autogeneration of mipmaps for each face of the texture, if it is enabled
1039	if(mNumRequestedMipmaps != 0 && (mUsage & TU_AUTOMIPMAP))
1040	{
1041	for(face=0; face<getNumFaces(); ++face)
1042	{
1043	GETLEVEL(face, 0)->_setMipmapping(true, mMipmapsHardwareGenerated, mpTex);
1044	}
1045	}
1046	}
1047	#undef GETLEVEL
1048	/****************************************************************************************/
1049	HardwarePixelBufferSharedPtr D3D9Texture::getBuffer(size_t face, size_t mipmap)
1050	{
1051	if(face >= getNumFaces())
1052	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "A three dimensional cube has six faces",
1053	"D3D9Texture::getBuffer");
1054	if(mipmap > mNumMipmaps)
1055	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Mipmap index out of range",
1056	"D3D9Texture::getBuffer");
1057	size_t idx = face*(mNumMipmaps+1) + mipmap;
1058	assert(idx < mSurfaceList.size());
1059	return mSurfaceList[idx];
1060	}
1061
1062
1063	/****************************************************************************************/
1064	bool D3D9Texture::releaseIfDefaultPool(void)
1065	{
1066	if(mD3DPool == D3DPOOL_DEFAULT)
1067	{
1068	LogManager::getSingleton().logMessage(
1069	"Releasing D3D9 default pool texture: " + mName);
1070	// Just free any internal resources, don't call unload() here
1071	// because we want the un-touched resource to keep its unloaded status
1072	// after device reset.
1073	freeInternalResources();
1074	LogManager::getSingleton().logMessage(
1075	"Released D3D9 default pool texture: " + mName);
1076	return true;
1077	}
1078	return false;
1079	}
1080	/****************************************************************************************/
1081	bool D3D9Texture::recreateIfDefaultPool(LPDIRECT3DDEVICE9 pDev)
1082	{
1083	bool ret = false;
1084	if(mD3DPool == D3DPOOL_DEFAULT)
1085	{
1086	ret = true;
1087	LogManager::getSingleton().logMessage(
1088	"Recreating D3D9 default pool texture: " + mName);
1089	// We just want to create the texture resources if:
1090	// 1. This is a render texture, or
1091	// 2. This is a manual texture with no loader, or
1092	// 3. This was an unloaded regular texture (preserve unloaded state)
1093	if ((mIsManual && !mLoader) \|\| (mUsage & TU_RENDERTARGET) \|\| !mIsLoaded)
1094	{
1095	// just recreate any internal resources
1096	createInternalResources();
1097	}
1098	// Otherwise, this is a regular loaded texture, or a manual texture with a loader
1099	else
1100	{
1101	// The internal resources already freed, need unload/load here:
1102	// 1. Make sure resource memory usage statistic correction.
1103	// 2. Don't call unload() in releaseIfDefaultPool() because we want
1104	// the un-touched resource keep unload status after device reset.
1105	unload();
1106	// if manual, we need to recreate internal resources since load() won't do that
1107	if (mIsManual)
1108	createInternalResources();
1109	load();
1110	}
1111	LogManager::getSingleton().logMessage(
1112	"Recreated D3D9 default pool texture: " + mName);
1113	}
1114
1115	return ret;
1116
1117	}
1118
1119
1120	/****************************************************************************************/
1121	}

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

Context Navigation

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

Download in other formats: