source: OGRE/trunk/ogrenew/RenderSystems/Direct3D9/src/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-----------------------------------------------------------------------------
3This source file is part of OGRE
4    (Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2005 The OGRE Team
8Also see acknowledgements in Readme.html
9
10This program is free software; you can redistribute it and/or modify it under
11the terms of the GNU Lesser General Public License as published by the Free Software
12Foundation; either version 2 of the License, or (at your option) any later
13version.
14
15This program is distributed in the hope that it will be useful, but WITHOUT
16ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18
19You should have received a copy of the GNU Lesser General Public License along with
20this program; if not, write to the Free Software Foundation, Inc., 59 Temple
21Place - Suite 330, Boston, MA 02111-1307, USA, or go to
22http://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
31namespace 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.