Context Navigation

OgreD3D9Mappings.cpp @ 692

Revision 692, 21.4 KB checked in by mattausch, 19 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 "OgreD3D9Mappings.h"
26	#include "OgreString.h"
27	#include "OgreStringConverter.h"
28	#include "OgreLogManager.h"
29	#include "OgreException.h"
30
31	namespace Ogre
32	{
33	//---------------------------------------------------------------------
34	DWORD D3D9Mappings::get(ShadeOptions so)
35	{
36	switch( so )
37	{
38	case SO_FLAT:
39	return D3DSHADE_FLAT;
40	case SO_GOURAUD:
41	return D3DSHADE_GOURAUD;
42	case SO_PHONG:
43	return D3DSHADE_PHONG;
44	}
45	return 0;
46	}
47	//---------------------------------------------------------------------
48	D3DLIGHTTYPE D3D9Mappings::get(Ogre::Light::LightTypes lightType)
49	{
50	switch( lightType )
51	{
52	case Light::LT_POINT:
53	return D3DLIGHT_POINT;
54	case Light::LT_DIRECTIONAL:
55	return D3DLIGHT_DIRECTIONAL;
56	case Light::LT_SPOTLIGHT:
57	return D3DLIGHT_SPOT;
58	}
59	return D3DLIGHT_FORCE_DWORD;
60	}
61	//---------------------------------------------------------------------
62	DWORD D3D9Mappings::get(TexCoordCalcMethod m, const D3DCAPS9& caps)
63	{
64	switch( m )
65	{
66	case TEXCALC_NONE:
67	return D3DTSS_TCI_PASSTHRU;
68	case TEXCALC_ENVIRONMENT_MAP_REFLECTION:
69	return D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR;
70	case TEXCALC_ENVIRONMENT_MAP_PLANAR:
71	if (caps.VertexProcessingCaps & D3DVTXPCAPS_TEXGEN_SPHEREMAP)
72	{
73	// Use sphere map if available
74	return D3DTSS_TCI_SPHEREMAP;
75	}
76	else
77	{
78	// If not, fall back on camera space reflection vector which isn't as good
79	return D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR;
80	}
81	case TEXCALC_ENVIRONMENT_MAP_NORMAL:
82	return D3DTSS_TCI_CAMERASPACENORMAL;
83	case TEXCALC_ENVIRONMENT_MAP:
84	if (caps.VertexProcessingCaps & D3DVTXPCAPS_TEXGEN_SPHEREMAP)
85	{
86	// Use sphere map if available
87	return D3DTSS_TCI_SPHEREMAP;
88	}
89	else
90	{
91	// If not, fall back on camera space normal which isn't as good
92	return D3DTSS_TCI_CAMERASPACENORMAL;
93	}
94	case TEXCALC_PROJECTIVE_TEXTURE:
95	return D3DTSS_TCI_CAMERASPACEPOSITION;
96	}
97	return 0;
98	}
99	//---------------------------------------------------------------------
100	D3DTEXTUREADDRESS D3D9Mappings::get(TextureUnitState::TextureAddressingMode tam)
101	{
102	switch( tam )
103	{
104	case TextureUnitState::TAM_WRAP:
105	return D3DTADDRESS_WRAP;
106	case TextureUnitState::TAM_MIRROR:
107	return D3DTADDRESS_MIRROR;
108	case TextureUnitState::TAM_CLAMP:
109	return D3DTADDRESS_CLAMP;
110	case TextureUnitState::TAM_BORDER:
111	return D3DTADDRESS_BORDER;
112	}
113	return D3DTADDRESS_FORCE_DWORD;
114	}
115	//---------------------------------------------------------------------
116	D3DTEXTURESTAGESTATETYPE D3D9Mappings::get(LayerBlendType lbt)
117	{
118	switch( lbt )
119	{
120	case LBT_COLOUR:
121	return D3DTSS_COLOROP;
122	case LBT_ALPHA:
123	return D3DTSS_ALPHAOP;
124	}
125	return D3DTSS_FORCE_DWORD;
126	}
127	//---------------------------------------------------------------------
128	DWORD D3D9Mappings::get(LayerBlendSource lbs)
129	{
130	switch( lbs )
131	{
132	case LBS_CURRENT:
133	return D3DTA_CURRENT;
134	case LBS_TEXTURE:
135	return D3DTA_TEXTURE;
136	case LBS_DIFFUSE:
137	return D3DTA_DIFFUSE;
138	case LBS_SPECULAR:
139	return D3DTA_SPECULAR;
140	case LBS_MANUAL:
141	return D3DTA_TFACTOR;
142	}
143	return 0;
144	}
145	//---------------------------------------------------------------------
146	DWORD D3D9Mappings::get(LayerBlendOperationEx lbo, const D3DCAPS9& devCaps)
147	{
148	switch( lbo )
149	{
150	case LBX_SOURCE1:
151	return D3DTOP_SELECTARG1;
152	case LBX_SOURCE2:
153	return D3DTOP_SELECTARG2;
154	case LBX_MODULATE:
155	return D3DTOP_MODULATE;
156	case LBX_MODULATE_X2:
157	return D3DTOP_MODULATE2X;
158	case LBX_MODULATE_X4:
159	return D3DTOP_MODULATE4X;
160	case LBX_ADD:
161	return D3DTOP_ADD;
162	case LBX_ADD_SIGNED:
163	return D3DTOP_ADDSIGNED;
164	case LBX_ADD_SMOOTH:
165	return D3DTOP_ADDSMOOTH;
166	case LBX_SUBTRACT:
167	return D3DTOP_SUBTRACT;
168	case LBX_BLEND_DIFFUSE_ALPHA:
169	return D3DTOP_BLENDDIFFUSEALPHA;
170	case LBX_BLEND_TEXTURE_ALPHA:
171	return D3DTOP_BLENDTEXTUREALPHA;
172	case LBX_BLEND_CURRENT_ALPHA:
173	return D3DTOP_BLENDCURRENTALPHA;
174	case LBX_BLEND_MANUAL:
175	return D3DTOP_BLENDFACTORALPHA;
176	case LBX_DOTPRODUCT:
177	if (devCaps.TextureOpCaps & D3DTEXOPCAPS_DOTPRODUCT3)
178	return D3DTOP_DOTPRODUCT3;
179	else
180	return D3DTOP_MODULATE;
181	case LBX_BLEND_DIFFUSE_COLOUR:
182	if (devCaps.TextureOpCaps & D3DTEXOPCAPS_LERP)
183	return D3DTOP_LERP;
184	else
185	return D3DTOP_MODULATE;
186	}
187	return 0;
188	}
189	//---------------------------------------------------------------------
190	D3DBLEND D3D9Mappings::get(SceneBlendFactor sbf)
191	{
192	switch( sbf )
193	{
194	case SBF_ONE:
195	return D3DBLEND_ONE;
196	case SBF_ZERO:
197	return D3DBLEND_ZERO;
198	case SBF_DEST_COLOUR:
199	return D3DBLEND_DESTCOLOR;
200	case SBF_SOURCE_COLOUR:
201	return D3DBLEND_SRCCOLOR;
202	case SBF_ONE_MINUS_DEST_COLOUR:
203	return D3DBLEND_INVDESTCOLOR;
204	case SBF_ONE_MINUS_SOURCE_COLOUR:
205	return D3DBLEND_INVSRCCOLOR;
206	case SBF_DEST_ALPHA:
207	return D3DBLEND_DESTALPHA;
208	case SBF_SOURCE_ALPHA:
209	return D3DBLEND_SRCALPHA;
210	case SBF_ONE_MINUS_DEST_ALPHA:
211	return D3DBLEND_INVDESTALPHA;
212	case SBF_ONE_MINUS_SOURCE_ALPHA:
213	return D3DBLEND_INVSRCALPHA;
214	}
215	return D3DBLEND_FORCE_DWORD;
216	}
217	//---------------------------------------------------------------------
218	DWORD D3D9Mappings::get(CompareFunction cf)
219	{
220	switch( cf )
221	{
222	case CMPF_ALWAYS_FAIL:
223	return D3DCMP_NEVER;
224	case CMPF_ALWAYS_PASS:
225	return D3DCMP_ALWAYS;
226	case CMPF_LESS:
227	return D3DCMP_LESS;
228	case CMPF_LESS_EQUAL:
229	return D3DCMP_LESSEQUAL;
230	case CMPF_EQUAL:
231	return D3DCMP_EQUAL;
232	case CMPF_NOT_EQUAL:
233	return D3DCMP_NOTEQUAL;
234	case CMPF_GREATER_EQUAL:
235	return D3DCMP_GREATEREQUAL;
236	case CMPF_GREATER:
237	return D3DCMP_GREATER;
238	};
239	return 0;
240	}
241	//---------------------------------------------------------------------
242	DWORD D3D9Mappings::get(CullingMode cm, bool flip)
243	{
244	switch( cm )
245	{
246	case CULL_NONE:
247	return D3DCULL_NONE;
248	case CULL_CLOCKWISE:
249	if( flip )
250	return D3DCULL_CCW;
251	else
252	return D3DCULL_CW;
253	case CULL_ANTICLOCKWISE:
254	if( flip )
255	return D3DCULL_CW;
256	else
257	return D3DCULL_CCW;
258	}
259	return 0;
260	}
261	//---------------------------------------------------------------------
262	D3DFOGMODE D3D9Mappings::get(FogMode fm)
263	{
264	switch( fm )
265	{
266	case FOG_EXP:
267	return D3DFOG_EXP;
268	case FOG_EXP2:
269	return D3DFOG_EXP2;
270	case FOG_LINEAR:
271	return D3DFOG_LINEAR;
272	}
273	return D3DFOG_FORCE_DWORD;
274	}
275	//---------------------------------------------------------------------
276	D3DFILLMODE D3D9Mappings::get(PolygonMode level)
277	{
278	switch(level)
279	{
280	case PM_POINTS:
281	return D3DFILL_POINT;
282	case PM_WIREFRAME:
283	return D3DFILL_WIREFRAME;
284	case PM_SOLID:
285	return D3DFILL_SOLID;
286	}
287	return D3DFILL_FORCE_DWORD;
288	}
289	//---------------------------------------------------------------------
290	DWORD D3D9Mappings::get(StencilOperation op, bool invert)
291	{
292	switch(op)
293	{
294	case SOP_KEEP:
295	return D3DSTENCILOP_KEEP;
296	case SOP_ZERO:
297	return D3DSTENCILOP_ZERO;
298	case SOP_REPLACE:
299	return D3DSTENCILOP_REPLACE;
300	case SOP_INCREMENT:
301	return invert? D3DSTENCILOP_DECRSAT : D3DSTENCILOP_INCRSAT;
302	case SOP_DECREMENT:
303	return invert? D3DSTENCILOP_INCRSAT : D3DSTENCILOP_DECRSAT;
304	case SOP_INCREMENT_WRAP:
305	return invert? D3DSTENCILOP_DECR : D3DSTENCILOP_INCR;
306	case SOP_DECREMENT_WRAP:
307	return invert? D3DSTENCILOP_INCR : D3DSTENCILOP_DECR;
308	case SOP_INVERT:
309	return D3DSTENCILOP_INVERT;
310	}
311	return 0;
312	}
313	//---------------------------------------------------------------------
314	D3DSAMPLERSTATETYPE D3D9Mappings::get(FilterType ft)
315	{
316	switch (ft)
317	{
318	case FT_MIN:
319	return D3DSAMP_MINFILTER;
320	break;
321	case FT_MAG:
322	return D3DSAMP_MAGFILTER;
323	break;
324	case FT_MIP:
325	return D3DSAMP_MIPFILTER;
326	break;
327	}
328
329	// to keep compiler happy
330	return D3DSAMP_MINFILTER;
331	}
332	//---------------------------------------------------------------------
333	DWORD D3D9Mappings::get(FilterType ft, FilterOptions fo, const D3DCAPS9& devCaps,
334	eD3DTexType texType)
335	{
336	// Assume normal
337	DWORD capsType = devCaps.TextureFilterCaps;
338
339	switch( texType )
340	{
341	case D3D_TEX_TYPE_NORMAL:
342	capsType = devCaps.TextureFilterCaps;
343	break;
344	case D3D_TEX_TYPE_CUBE:
345	capsType = devCaps.CubeTextureFilterCaps;
346	break;
347	case D3D_TEX_TYPE_VOLUME:
348	capsType = devCaps.VolumeTextureFilterCaps;
349	break;
350	}
351
352	switch (ft)
353	{
354	case FT_MIN:
355	switch( fo )
356	{
357	// NOTE: Fall through if device doesn't support requested type
358	case FO_ANISOTROPIC:
359	if( capsType & D3DPTFILTERCAPS_MINFANISOTROPIC )
360	{
361	return D3DTEXF_ANISOTROPIC;
362	break;
363	}
364	case FO_LINEAR:
365	if( capsType & D3DPTFILTERCAPS_MINFLINEAR )
366	{
367	return D3DTEXF_LINEAR;
368	break;
369	}
370	case FO_POINT:
371	case FO_NONE:
372	return D3DTEXF_POINT;
373	break;
374	}
375	break;
376	case FT_MAG:
377	switch( fo )
378	{
379	// NOTE: Fall through if device doesn't support requested type
380	case FO_ANISOTROPIC:
381	if( capsType & D3DPTFILTERCAPS_MAGFANISOTROPIC )
382	{
383	return D3DTEXF_ANISOTROPIC;
384	break;
385	}
386	case FO_LINEAR:
387	if( capsType & D3DPTFILTERCAPS_MAGFLINEAR )
388	{
389	return D3DTEXF_LINEAR;
390	break;
391	}
392	case FO_POINT:
393	case FO_NONE:
394	return D3DTEXF_POINT;
395	break;
396	}
397	break;
398	case FT_MIP:
399	switch( fo )
400	{
401	case FO_ANISOTROPIC:
402	case FO_LINEAR:
403	if( capsType & D3DPTFILTERCAPS_MIPFLINEAR )
404	{
405	return D3DTEXF_LINEAR;
406	break;
407	}
408	case FO_POINT:
409	if( capsType & D3DPTFILTERCAPS_MIPFPOINT )
410	{
411	return D3DTEXF_POINT;
412	break;
413	}
414	case FO_NONE:
415	return D3DTEXF_NONE;
416	break;
417	}
418	break;
419	}
420
421	// should never get here
422	return 0;
423
424	}
425	//---------------------------------------------------------------------
426	D3D9Mappings::eD3DTexType D3D9Mappings::get(TextureType ogreTexType)
427	{
428	switch( ogreTexType )
429	{
430	case TEX_TYPE_1D :
431	case TEX_TYPE_2D :
432	return D3D9Mappings::D3D_TEX_TYPE_NORMAL;
433	case TEX_TYPE_CUBE_MAP :
434	return D3D9Mappings::D3D_TEX_TYPE_CUBE;
435	case TEX_TYPE_3D :
436	return D3D9Mappings::D3D_TEX_TYPE_VOLUME;
437	}
438	return D3D9Mappings::D3D_TEX_TYPE_NONE;
439	}
440	//---------------------------------------------------------------------
441	DWORD D3D9Mappings::get(HardwareBuffer::Usage usage)
442	{
443	DWORD ret = 0;
444	if (usage & HardwareBuffer::HBU_DYNAMIC)
445	{
446	#if OGRE_D3D_MANAGE_BUFFERS
447	// Only add the dynamic flag for default pool, and
448	// we use default pool when buffer is discardable
449	if (usage & HardwareBuffer::HBU_DISCARDABLE)
450	ret \|= D3DUSAGE_DYNAMIC;
451	#else
452	ret \|= D3DUSAGE_DYNAMIC;
453	#endif
454	}
455	if (usage & HardwareBuffer::HBU_WRITE_ONLY)
456	{
457	ret \|= D3DUSAGE_WRITEONLY;
458	}
459	return ret;
460	}
461	//---------------------------------------------------------------------
462	DWORD D3D9Mappings::get(HardwareBuffer::LockOptions options, HardwareBuffer::Usage usage)
463	{
464	DWORD ret = 0;
465	if (options == HardwareBuffer::HBL_DISCARD)
466	{
467	#if OGRE_D3D_MANAGE_BUFFERS
468	// Only add the discard flag for dynamic usgae and default pool
469	if ((usage & HardwareBuffer::HBU_DYNAMIC) &&
470	(usage & HardwareBuffer::HBU_DISCARDABLE))
471	ret \|= D3DLOCK_DISCARD;
472	#else
473	// D3D doesn't like discard or no_overwrite on non-dynamic buffers
474	if (usage & HardwareBuffer::HBU_DYNAMIC)
475	ret \|= D3DLOCK_DISCARD;
476	#endif
477	}
478	if (options == HardwareBuffer::HBL_READ_ONLY)
479	{
480	// D3D debug runtime doesn't like you locking managed buffers readonly
481	// when they were created with write-only (even though you CAN read
482	// from the software backed version)
483	if (!(usage & HardwareBuffer::HBU_WRITE_ONLY))
484	ret \|= D3DLOCK_READONLY;
485
486	}
487	if (options == HardwareBuffer::HBL_NO_OVERWRITE)
488	{
489	#if OGRE_D3D_MANAGE_BUFFERS
490	// Only add the nooverwrite flag for dynamic usgae and default pool
491	if ((usage & HardwareBuffer::HBU_DYNAMIC) &&
492	(usage & HardwareBuffer::HBU_DISCARDABLE))
493	ret \|= D3DLOCK_NOOVERWRITE;
494	#else
495	// D3D doesn't like discard or no_overwrite on non-dynamic buffers
496	if (usage & HardwareBuffer::HBU_DYNAMIC)
497	ret \|= D3DLOCK_NOOVERWRITE;
498	#endif
499	}
500
501	return ret;
502	}
503	//---------------------------------------------------------------------
504	D3DFORMAT D3D9Mappings::get(HardwareIndexBuffer::IndexType itype)
505	{
506	if (itype == HardwareIndexBuffer::IT_32BIT)
507	{
508	return D3DFMT_INDEX32;
509	}
510	else
511	{
512	return D3DFMT_INDEX16;
513	}
514	}
515	//---------------------------------------------------------------------
516	D3DDECLTYPE D3D9Mappings::get(VertexElementType vType)
517	{
518	switch (vType)
519	{
520	case VET_COLOUR:
521	case VET_COLOUR_ABGR:
522	case VET_COLOUR_ARGB:
523	return D3DDECLTYPE_D3DCOLOR;
524	break;
525	case VET_FLOAT1:
526	return D3DDECLTYPE_FLOAT1;
527	break;
528	case VET_FLOAT2:
529	return D3DDECLTYPE_FLOAT2;
530	break;
531	case VET_FLOAT3:
532	return D3DDECLTYPE_FLOAT3;
533	break;
534	case VET_FLOAT4:
535	return D3DDECLTYPE_FLOAT4;
536	break;
537	case VET_SHORT2:
538	return D3DDECLTYPE_SHORT2;
539	break;
540	case VET_SHORT4:
541	return D3DDECLTYPE_SHORT4;
542	break;
543	case VET_UBYTE4:
544	return D3DDECLTYPE_UBYTE4;
545	break;
546	}
547	// to keep compiler happy
548	return D3DDECLTYPE_FLOAT3;
549	}
550	//---------------------------------------------------------------------
551	D3DDECLUSAGE D3D9Mappings::get(VertexElementSemantic sem)
552	{
553	switch (sem)
554	{
555	case VES_BLEND_INDICES:
556	return D3DDECLUSAGE_BLENDINDICES;
557	break;
558	case VES_BLEND_WEIGHTS:
559	return D3DDECLUSAGE_BLENDWEIGHT;
560	break;
561	case VES_DIFFUSE:
562	return D3DDECLUSAGE_COLOR; // NB index will differentiate
563	break;
564	case VES_SPECULAR:
565	return D3DDECLUSAGE_COLOR; // NB index will differentiate
566	break;
567	case VES_NORMAL:
568	return D3DDECLUSAGE_NORMAL;
569	break;
570	case VES_POSITION:
571	return D3DDECLUSAGE_POSITION;
572	break;
573	case VES_TEXTURE_COORDINATES:
574	return D3DDECLUSAGE_TEXCOORD;
575	break;
576	case VES_BINORMAL:
577	return D3DDECLUSAGE_BINORMAL;
578	break;
579	case VES_TANGENT:
580	return D3DDECLUSAGE_TANGENT;
581	break;
582	}
583	// to keep compiler happy
584	return D3DDECLUSAGE_POSITION;
585	}
586	//---------------------------------------------------------------------
587	D3DXMATRIX D3D9Mappings::makeD3DXMatrix( const Matrix4& mat )
588	{
589	// Transpose matrix
590	// D3D9 uses row vectors i.e. V*M
591	// Ogre, OpenGL and everything else uses column vectors i.e. M*V
592	D3DXMATRIX d3dMat;
593	d3dMat.m[0][0] = mat[0][0];
594	d3dMat.m[0][1] = mat[1][0];
595	d3dMat.m[0][2] = mat[2][0];
596	d3dMat.m[0][3] = mat[3][0];
597
598	d3dMat.m[1][0] = mat[0][1];
599	d3dMat.m[1][1] = mat[1][1];
600	d3dMat.m[1][2] = mat[2][1];
601	d3dMat.m[1][3] = mat[3][1];
602
603	d3dMat.m[2][0] = mat[0][2];
604	d3dMat.m[2][1] = mat[1][2];
605	d3dMat.m[2][2] = mat[2][2];
606	d3dMat.m[2][3] = mat[3][2];
607
608	d3dMat.m[3][0] = mat[0][3];
609	d3dMat.m[3][1] = mat[1][3];
610	d3dMat.m[3][2] = mat[2][3];
611	d3dMat.m[3][3] = mat[3][3];
612
613	return d3dMat;
614	}
615	//---------------------------------------------------------------------
616	Matrix4 D3D9Mappings::convertD3DXMatrix( const D3DXMATRIX& mat )
617	{
618	Matrix4 ogreMat;
619	ogreMat[0][0] = mat.m[0][0];
620	ogreMat[1][0] = mat.m[0][1];
621	ogreMat[2][0] = mat.m[0][2];
622	ogreMat[3][0] = mat.m[0][3];
623
624	ogreMat[0][1] = mat.m[1][0];
625	ogreMat[1][1] = mat.m[1][1];
626	ogreMat[2][1] = mat.m[1][2];
627	ogreMat[3][1] = mat.m[1][3];
628
629	ogreMat[0][2] = mat.m[2][0];
630	ogreMat[1][2] = mat.m[2][1];
631	ogreMat[2][2] = mat.m[2][2];
632	ogreMat[3][2] = mat.m[2][3];
633
634	ogreMat[0][3] = mat.m[3][0];
635	ogreMat[1][3] = mat.m[3][1];
636	ogreMat[2][3] = mat.m[3][2];
637	ogreMat[3][3] = mat.m[3][3];
638
639	return ogreMat;
640	}
641	/****************************************************************************************/
642	PixelFormat D3D9Mappings::_getPF(D3DFORMAT d3dPF)
643	{
644	switch(d3dPF)
645	{
646	case D3DFMT_A8:
647	return PF_A8;
648	case D3DFMT_L8:
649	return PF_L8;
650	case D3DFMT_L16:
651	return PF_L16;
652	case D3DFMT_A4L4:
653	return PF_A4L4;
654	case D3DFMT_A8L8:
655	return PF_BYTE_LA; // Assume little endian here
656	case D3DFMT_R3G3B2:
657	return PF_R3G3B2;
658	case D3DFMT_A1R5G5B5:
659	return PF_A1R5G5B5;
660	case D3DFMT_A4R4G4B4:
661	return PF_A4R4G4B4;
662	case D3DFMT_R5G6B5:
663	return PF_R5G6B5;
664	case D3DFMT_R8G8B8:
665	return PF_R8G8B8;
666	case D3DFMT_X8R8G8B8:
667	return PF_X8R8G8B8;
668	case D3DFMT_A8R8G8B8:
669	return PF_A8R8G8B8;
670	case D3DFMT_X8B8G8R8:
671	return PF_X8B8G8R8;
672	case D3DFMT_A8B8G8R8:
673	return PF_A8B8G8R8;
674	case D3DFMT_A2R10G10B10:
675	return PF_A2R10G10B10;
676	case D3DFMT_A2B10G10R10:
677	return PF_A2B10G10R10;
678	case D3DFMT_R16F:
679	return PF_FLOAT16_R;
680	case D3DFMT_A16B16G16R16F:
681	return PF_FLOAT16_RGBA;
682	case D3DFMT_R32F:
683	return PF_FLOAT32_R;
684	case D3DFMT_A32B32G32R32F:
685	return PF_FLOAT32_RGBA;
686	case D3DFMT_A16B16G16R16:
687	return PF_SHORT_RGBA;
688	case D3DFMT_DXT1:
689	return PF_DXT1;
690	case D3DFMT_DXT2:
691	return PF_DXT2;
692	case D3DFMT_DXT3:
693	return PF_DXT3;
694	case D3DFMT_DXT4:
695	return PF_DXT4;
696	case D3DFMT_DXT5:
697	return PF_DXT5;
698	default:
699	return PF_UNKNOWN;
700	}
701	}
702	/****************************************************************************************/
703	D3DFORMAT D3D9Mappings::_getPF(PixelFormat ogrePF)
704	{
705	switch(ogrePF)
706	{
707	case PF_L8:
708	return D3DFMT_L8;
709	case PF_L16:
710	return D3DFMT_L16;
711	case PF_A8:
712	return D3DFMT_A8;
713	case PF_A4L4:
714	return D3DFMT_A4L4;
715	case PF_BYTE_LA:
716	return D3DFMT_A8L8; // Assume little endian here
717	case PF_R3G3B2:
718	return D3DFMT_R3G3B2;
719	case PF_A1R5G5B5:
720	return D3DFMT_A1R5G5B5;
721	case PF_R5G6B5:
722	return D3DFMT_R5G6B5;
723	case PF_A4R4G4B4:
724	return D3DFMT_A4R4G4B4;
725	case PF_R8G8B8:
726	return D3DFMT_R8G8B8;
727	case PF_A8R8G8B8:
728	return D3DFMT_A8R8G8B8;
729	case PF_A8B8G8R8:
730	return D3DFMT_A8B8G8R8;
731	case PF_X8R8G8B8:
732	return D3DFMT_X8R8G8B8;
733	case PF_X8B8G8R8:
734	return D3DFMT_X8B8G8R8;
735	case PF_A2B10G10R10:
736	return D3DFMT_A2B10G10R10;
737	case PF_A2R10G10B10:
738	return D3DFMT_A2R10G10B10;
739	case PF_FLOAT16_R:
740	return D3DFMT_R16F;
741	case PF_FLOAT16_RGBA:
742	return D3DFMT_A16B16G16R16F;
743	case PF_FLOAT32_R:
744	return D3DFMT_R32F;
745	case PF_FLOAT32_RGBA:
746	return D3DFMT_A32B32G32R32F;
747	case PF_SHORT_RGBA:
748	return D3DFMT_A16B16G16R16;
749	case PF_DXT1:
750	return D3DFMT_DXT1;
751	case PF_DXT2:
752	return D3DFMT_DXT2;
753	case PF_DXT3:
754	return D3DFMT_DXT3;
755	case PF_DXT4:
756	return D3DFMT_DXT4;
757	case PF_DXT5:
758	return D3DFMT_DXT5;
759	case PF_UNKNOWN:
760	default:
761	return D3DFMT_UNKNOWN;
762	}
763	}
764	/****************************************************************************************/
765	PixelFormat D3D9Mappings::_getClosestSupportedPF(PixelFormat ogrePF)
766	{
767	if (_getPF(ogrePF) != D3DFMT_UNKNOWN)
768	{
769	return ogrePF;
770	}
771	switch(ogrePF)
772	{
773	case PF_B5G6R5:
774	return PF_R5G6B5;
775	case PF_B8G8R8:
776	return PF_R8G8B8;
777	case PF_B8G8R8A8:
778	return PF_A8R8G8B8;
779	case PF_FLOAT16_RGB:
780	return PF_FLOAT16_RGBA;
781	case PF_FLOAT32_RGB:
782	return PF_FLOAT32_RGBA;
783	case PF_UNKNOWN:
784	default:
785	return PF_A8R8G8B8;
786	}
787	}
788
789	}

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

Context Navigation

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

Download in other formats: