Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/RenderSystems/Direct3D9/src/OgreD3D9Mappings.cpp @ 1

Last change on this file since 1 was 1, checked in by landauf, 17 years ago

File size: 21.6 KB

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

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

Download in other formats: