Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

OgreD3D9Mappings.cpp

Go to the documentation of this file.
00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004     (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://www.ogre3d.org/
00006 
00007 Copyright © 2000-2002 The OGRE Team
00008 Also see acknowledgements in Readme.html
00009 
00010 This program is free software; you can redistribute it and/or modify it under
00011 the terms of the GNU Lesser General Public License as published by the Free Software
00012 Foundation; either version 2 of the License, or (at your option) any later
00013 version.
00014 
00015 This program is distributed in the hope that it will be useful, but WITHOUT
00016 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00017 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public License along with
00020 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
00021 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
00022 http://www.gnu.org/copyleft/lesser.txt.
00023 -----------------------------------------------------------------------------
00024 */
00025 #include "OgreD3D9Mappings.h"
00026 #include "OgreString.h"
00027 #include "OgreStringConverter.h"
00028 #include "OgreLogManager.h"
00029 #include "OgreException.h"
00030 
00031 namespace Ogre 
00032 {
00033     //---------------------------------------------------------------------
00034     DWORD D3D9Mappings::get(ShadeOptions so)
00035     {
00036         switch( so )
00037         {
00038         case SO_FLAT:
00039             return D3DSHADE_FLAT;
00040         case SO_GOURAUD:
00041             return D3DSHADE_GOURAUD;
00042         case SO_PHONG:
00043             return D3DSHADE_PHONG;
00044         }
00045         return 0;
00046     }
00047     //---------------------------------------------------------------------
00048     D3DLIGHTTYPE D3D9Mappings::get(Ogre::Light::LightTypes lightType)
00049     {
00050         switch( lightType )
00051         {
00052         case Light::LT_POINT:
00053             return D3DLIGHT_POINT;
00054         case Light::LT_DIRECTIONAL:
00055             return D3DLIGHT_DIRECTIONAL;
00056         case Light::LT_SPOTLIGHT:
00057             return D3DLIGHT_SPOT;
00058         }
00059         return D3DLIGHT_FORCE_DWORD;
00060     }
00061     //---------------------------------------------------------------------
00062     DWORD D3D9Mappings::get(TexCoordCalcMethod m, const D3DCAPS9& caps)
00063     {
00064         switch( m )
00065         {
00066         case TEXCALC_NONE:
00067             return D3DTSS_TCI_PASSTHRU;
00068         case TEXCALC_ENVIRONMENT_MAP_REFLECTION:
00069             return D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR;
00070         case TEXCALC_ENVIRONMENT_MAP_PLANAR:
00071             if (caps.VertexProcessingCaps & D3DVTXPCAPS_TEXGEN_SPHEREMAP)
00072             {
00073                 // Use sphere map if available
00074                 return D3DTSS_TCI_SPHEREMAP;
00075             }
00076             else
00077             {
00078                 // If not, fall back on camera space reflection vector which isn't as good
00079                 return D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR;
00080             }
00081         case TEXCALC_ENVIRONMENT_MAP_NORMAL:
00082             return D3DTSS_TCI_CAMERASPACENORMAL;
00083         case TEXCALC_ENVIRONMENT_MAP:
00084             if (caps.VertexProcessingCaps & D3DVTXPCAPS_TEXGEN_SPHEREMAP)
00085             {
00086                 // Use sphere map if available
00087                 return D3DTSS_TCI_SPHEREMAP;
00088             }
00089             else
00090             {
00091                 // If not, fall back on camera space normal which isn't as good
00092                 return D3DTSS_TCI_CAMERASPACENORMAL;
00093             }
00094         case TEXCALC_PROJECTIVE_TEXTURE:
00095             return D3DTSS_TCI_CAMERASPACEPOSITION;
00096         }
00097         return 0;
00098     }
00099     //---------------------------------------------------------------------
00100     D3DTEXTUREADDRESS D3D9Mappings::get(TextureUnitState::TextureAddressingMode tam)
00101     {
00102         switch( tam )
00103         {
00104         case TextureUnitState::TAM_WRAP:
00105             return D3DTADDRESS_WRAP;
00106         case TextureUnitState::TAM_MIRROR:
00107             return D3DTADDRESS_MIRROR;
00108         case TextureUnitState::TAM_CLAMP:
00109             return D3DTADDRESS_CLAMP;
00110         }
00111         return D3DTADDRESS_FORCE_DWORD;
00112     }
00113     //---------------------------------------------------------------------
00114     D3DTEXTURESTAGESTATETYPE D3D9Mappings::get(LayerBlendType lbt)
00115     {
00116         switch( lbt )
00117         {
00118         case LBT_COLOUR:
00119             return D3DTSS_COLOROP;
00120         case LBT_ALPHA:
00121             return D3DTSS_ALPHAOP;
00122         }
00123         return  D3DTSS_FORCE_DWORD;
00124     }
00125     //---------------------------------------------------------------------
00126     DWORD D3D9Mappings::get(LayerBlendSource lbs)
00127     {
00128         switch( lbs )
00129         {
00130         case LBS_CURRENT:
00131             return D3DTA_CURRENT;
00132         case LBS_TEXTURE:
00133             return D3DTA_TEXTURE;
00134         case LBS_DIFFUSE:
00135             return D3DTA_DIFFUSE;
00136         case LBS_SPECULAR:
00137             return D3DTA_SPECULAR;
00138         case LBS_MANUAL:
00139             return D3DTA_TFACTOR;
00140         }
00141         return 0;
00142     }
00143     //---------------------------------------------------------------------
00144     DWORD D3D9Mappings::get(LayerBlendOperationEx lbo, D3DCAPS9 devCaps)
00145     {
00146         switch( lbo )
00147         {
00148         case LBX_SOURCE1:
00149             return D3DTOP_SELECTARG1;
00150         case LBX_SOURCE2:
00151             return D3DTOP_SELECTARG2;
00152         case LBX_MODULATE:
00153             return D3DTOP_MODULATE;
00154         case LBX_MODULATE_X2:
00155             return D3DTOP_MODULATE2X;
00156         case LBX_MODULATE_X4:
00157             return D3DTOP_MODULATE4X;
00158         case LBX_ADD:
00159             return D3DTOP_ADD;
00160         case LBX_ADD_SIGNED:
00161             return D3DTOP_ADDSIGNED;
00162         case LBX_ADD_SMOOTH:
00163             return D3DTOP_ADDSMOOTH;
00164         case LBX_SUBTRACT:
00165             return D3DTOP_SUBTRACT;
00166         case LBX_BLEND_DIFFUSE_ALPHA:
00167             return D3DTOP_BLENDDIFFUSEALPHA;
00168         case LBX_BLEND_TEXTURE_ALPHA:
00169             return D3DTOP_BLENDTEXTUREALPHA;
00170         case LBX_BLEND_CURRENT_ALPHA:
00171             return D3DTOP_BLENDCURRENTALPHA;
00172         case LBX_BLEND_MANUAL:
00173             return D3DTOP_BLENDFACTORALPHA;
00174         case LBX_DOTPRODUCT:
00175             if (devCaps.TextureOpCaps & D3DTEXOPCAPS_DOTPRODUCT3)
00176                 return D3DTOP_DOTPRODUCT3;
00177             else
00178                 return D3DTOP_MODULATE;
00179         }
00180         return 0;
00181     }
00182     //---------------------------------------------------------------------
00183     D3DBLEND D3D9Mappings::get(SceneBlendFactor sbf)
00184     {
00185         switch( sbf )
00186         {
00187         case SBF_ONE:
00188             return D3DBLEND_ONE;
00189         case SBF_ZERO:
00190             return D3DBLEND_ZERO;
00191         case SBF_DEST_COLOUR:
00192             return D3DBLEND_DESTCOLOR;
00193         case SBF_SOURCE_COLOUR:
00194             return D3DBLEND_SRCCOLOR;
00195         case SBF_ONE_MINUS_DEST_COLOUR:
00196             return D3DBLEND_INVDESTCOLOR;
00197         case SBF_ONE_MINUS_SOURCE_COLOUR:
00198             return D3DBLEND_INVSRCCOLOR;
00199         case SBF_DEST_ALPHA:
00200             return D3DBLEND_DESTALPHA;
00201         case SBF_SOURCE_ALPHA:
00202             return D3DBLEND_SRCALPHA;
00203         case SBF_ONE_MINUS_DEST_ALPHA:
00204             return D3DBLEND_INVDESTALPHA;
00205         case SBF_ONE_MINUS_SOURCE_ALPHA:
00206             return D3DBLEND_INVSRCALPHA;
00207         }
00208         return D3DBLEND_FORCE_DWORD;
00209     }
00210     //---------------------------------------------------------------------
00211     DWORD D3D9Mappings::get(CompareFunction cf)
00212     {
00213         switch( cf )
00214         {
00215         case CMPF_ALWAYS_FAIL:
00216             return D3DCMP_NEVER;
00217         case CMPF_ALWAYS_PASS:
00218             return D3DCMP_ALWAYS;
00219         case CMPF_LESS:
00220             return D3DCMP_LESS;
00221         case CMPF_LESS_EQUAL:
00222             return D3DCMP_LESSEQUAL;
00223         case CMPF_EQUAL:
00224             return D3DCMP_EQUAL;
00225         case CMPF_NOT_EQUAL:
00226             return D3DCMP_NOTEQUAL;
00227         case CMPF_GREATER_EQUAL:
00228             return D3DCMP_GREATEREQUAL;
00229         case CMPF_GREATER:
00230             return D3DCMP_GREATER;
00231         };
00232         return 0;
00233     }
00234     //---------------------------------------------------------------------
00235     DWORD D3D9Mappings::get(CullingMode cm, bool flip)
00236     {
00237         switch( cm )
00238         {
00239         case CULL_NONE:
00240             return D3DCULL_NONE;
00241         case CULL_CLOCKWISE:
00242             if( flip )
00243                 return D3DCULL_CCW;
00244             else
00245                 return D3DCULL_CW;
00246         case CULL_ANTICLOCKWISE:
00247             if( flip )
00248                 return D3DCULL_CW;
00249             else
00250                 return D3DCULL_CCW;
00251         }
00252         return 0;
00253     }
00254     //---------------------------------------------------------------------
00255     D3DFOGMODE D3D9Mappings::get(FogMode fm)
00256     {
00257         switch( fm )
00258         {
00259         case FOG_EXP:
00260             return D3DFOG_EXP;
00261         case FOG_EXP2:
00262             return D3DFOG_EXP2;
00263         case FOG_LINEAR:
00264             return D3DFOG_LINEAR;
00265         }
00266         return D3DFOG_FORCE_DWORD;
00267     }
00268     //---------------------------------------------------------------------
00269     D3DFILLMODE D3D9Mappings::get(SceneDetailLevel level)
00270     {
00271         switch(level)
00272         {
00273         case SDL_POINTS:
00274             return D3DFILL_POINT;
00275         case SDL_WIREFRAME:
00276             return D3DFILL_WIREFRAME;
00277         case SDL_SOLID:
00278             return D3DFILL_SOLID;
00279         }
00280         return D3DFILL_FORCE_DWORD;
00281     }
00282     //---------------------------------------------------------------------
00283     DWORD D3D9Mappings::get(StencilOperation op, bool invert)
00284     {
00285         switch(op)
00286         {
00287         case SOP_KEEP:
00288             return D3DSTENCILOP_KEEP;
00289         case SOP_ZERO:
00290             return D3DSTENCILOP_ZERO;
00291         case SOP_REPLACE:
00292             return D3DSTENCILOP_REPLACE;
00293         case SOP_INCREMENT:
00294             return invert? D3DSTENCILOP_DECRSAT : D3DSTENCILOP_INCRSAT;
00295         case SOP_DECREMENT:
00296             return invert? D3DSTENCILOP_INCRSAT : D3DSTENCILOP_DECRSAT;
00297         case SOP_INCREMENT_WRAP:
00298             return invert? D3DSTENCILOP_DECR : D3DSTENCILOP_INCR;
00299         case SOP_DECREMENT_WRAP:
00300             return invert? D3DSTENCILOP_INCR : D3DSTENCILOP_DECR;
00301         case SOP_INVERT:
00302             return D3DSTENCILOP_INVERT;
00303         }
00304         return 0;
00305     }
00306     //---------------------------------------------------------------------
00307     D3DSAMPLERSTATETYPE D3D9Mappings::get(FilterType ft)
00308     {
00309         switch (ft)
00310         {
00311         case FT_MIN:
00312             return D3DSAMP_MINFILTER;
00313             break;
00314         case FT_MAG:
00315             return D3DSAMP_MAGFILTER;
00316             break;
00317         case FT_MIP:
00318             return D3DSAMP_MIPFILTER;
00319             break;
00320         }
00321 
00322         // to keep compiler happy
00323         return D3DSAMP_MINFILTER;
00324     }
00325     //---------------------------------------------------------------------
00326     DWORD D3D9Mappings::get(FilterType ft, FilterOptions fo, D3DCAPS9 devCaps, 
00327         eD3DTexType texType)
00328     {
00329         DWORD capsType;
00330 
00331         switch( texType )
00332         {
00333         case D3D_TEX_TYPE_NORMAL:
00334             capsType = devCaps.TextureFilterCaps;
00335             break;
00336         case D3D_TEX_TYPE_CUBE:
00337             capsType = devCaps.CubeTextureFilterCaps;
00338             break;
00339         case D3D_TEX_TYPE_VOLUME:
00340             capsType = devCaps.VolumeTextureFilterCaps;
00341             break;
00342         }
00343 
00344         switch (ft)
00345         {
00346         case FT_MIN:
00347             switch( fo )
00348             {
00349                 // NOTE: Fall through if device doesn't support requested type
00350             case FO_ANISOTROPIC:
00351                 if( capsType & D3DPTFILTERCAPS_MINFANISOTROPIC )
00352                 {
00353                     return D3DTEXF_ANISOTROPIC;
00354                     break;
00355                 }
00356             case FO_LINEAR:
00357                 if( capsType & D3DPTFILTERCAPS_MINFLINEAR )
00358                 {
00359                     return D3DTEXF_LINEAR;
00360                     break;
00361                 }
00362             case FO_POINT:
00363             case TFO_NONE:
00364                 return D3DTEXF_POINT;
00365                 break;
00366             }
00367             break;
00368         case FT_MAG:
00369             switch( fo )
00370             {
00371             // NOTE: Fall through if device doesn't support requested type
00372             case FO_ANISOTROPIC:
00373                 if( capsType & D3DPTFILTERCAPS_MAGFANISOTROPIC )
00374                 {
00375                     return D3DTEXF_ANISOTROPIC;
00376                     break;
00377                 }
00378             case FO_LINEAR:
00379                 if( capsType & D3DPTFILTERCAPS_MAGFLINEAR )
00380                 {
00381                     return D3DTEXF_LINEAR;
00382                     break;
00383                 }
00384             case FO_POINT:
00385             case FO_NONE:
00386                 return D3DTEXF_POINT;
00387                 break;
00388             }
00389             break;
00390         case FT_MIP:
00391             switch( fo )
00392             {
00393             case FO_ANISOTROPIC:
00394             case FO_LINEAR:
00395                 if( capsType & D3DPTFILTERCAPS_MIPFLINEAR )
00396                 {
00397                     return D3DTEXF_LINEAR;
00398                     break;
00399                 }
00400             case FO_POINT:
00401                 if( capsType & D3DPTFILTERCAPS_MIPFPOINT )
00402                 {
00403                     return D3DTEXF_POINT;
00404                     break;
00405                 }
00406             case TFO_NONE:
00407                 return D3DTEXF_NONE;
00408                 break;
00409             }
00410             break;
00411         }
00412 
00413         // should never get here
00414         return 0;
00415 
00416     }
00417     //---------------------------------------------------------------------
00418     D3D9Mappings::eD3DTexType D3D9Mappings::get(TextureType ogreTexType)
00419     {
00420         switch( ogreTexType )
00421         {
00422         case TEX_TYPE_1D :
00423         case TEX_TYPE_2D :
00424             return D3D9Mappings::D3D_TEX_TYPE_NORMAL;
00425         case TEX_TYPE_CUBE_MAP :
00426             return D3D9Mappings::D3D_TEX_TYPE_CUBE;
00427         case TEX_TYPE_3D :
00428             return D3D9Mappings::D3D_TEX_TYPE_VOLUME;
00429         }
00430         return D3D9Mappings::D3D_TEX_TYPE_NONE;
00431     }
00432     //---------------------------------------------------------------------
00433     DWORD D3D9Mappings::get(HardwareBuffer::Usage usage)
00434     {
00435         DWORD ret = 0;
00436         if (usage & HardwareBuffer::HBU_DYNAMIC)
00437         {
00438             ret |= D3DUSAGE_DYNAMIC;
00439         }
00440         if (usage & HardwareBuffer::HBU_WRITE_ONLY)
00441         {
00442             ret |= D3DUSAGE_WRITEONLY;
00443         }
00444         return ret;
00445     }
00446     //---------------------------------------------------------------------
00447     DWORD D3D9Mappings::get(HardwareBuffer::LockOptions options)
00448     {
00449         DWORD ret = 0;
00450         if (options == HardwareBuffer::HBL_DISCARD)
00451         {
00452             ret |= D3DLOCK_DISCARD;
00453         }
00454         if (options == HardwareBuffer::HBL_READ_ONLY)
00455         {
00456             ret |= D3DLOCK_READONLY;
00457         }
00458         if (options == HardwareBuffer::HBL_NO_OVERWRITE)
00459         {
00460             ret |= D3DLOCK_NOOVERWRITE;
00461         }
00462 
00463         return ret;
00464     }
00465     //---------------------------------------------------------------------
00466     D3DFORMAT D3D9Mappings::get(HardwareIndexBuffer::IndexType itype)
00467     {
00468         if (itype == HardwareIndexBuffer::IT_32BIT)
00469         {
00470             return D3DFMT_INDEX32;
00471         }
00472         else
00473         {
00474             return D3DFMT_INDEX16;
00475         }
00476     }
00477     //---------------------------------------------------------------------
00478     D3DDECLTYPE D3D9Mappings::get(VertexElementType vType)
00479     {
00480         switch (vType)
00481         {
00482         case VET_COLOUR:
00483             return D3DDECLTYPE_D3DCOLOR;
00484             break;
00485         case VET_FLOAT1:
00486             return D3DDECLTYPE_FLOAT1;
00487             break;
00488         case VET_FLOAT2:
00489             return D3DDECLTYPE_FLOAT2;
00490             break;
00491         case VET_FLOAT3:
00492             return D3DDECLTYPE_FLOAT3;
00493             break;
00494         case VET_FLOAT4:
00495             return D3DDECLTYPE_FLOAT4;
00496             break;
00497         case VET_SHORT2:
00498             return D3DDECLTYPE_SHORT2;
00499             break;
00500         case VET_SHORT4:
00501             return D3DDECLTYPE_SHORT4;
00502             break;
00503         case VET_UBYTE4:
00504             return D3DDECLTYPE_UBYTE4;
00505             break;
00506         }
00507         // to keep compiler happy
00508         return D3DDECLTYPE_FLOAT3;
00509     }
00510     //---------------------------------------------------------------------
00511     D3DDECLUSAGE D3D9Mappings::get(VertexElementSemantic sem)
00512     {
00513         switch (sem)
00514         {
00515         case VES_BLEND_INDICES:
00516             return D3DDECLUSAGE_BLENDINDICES;
00517             break;
00518         case VES_BLEND_WEIGHTS:
00519             return D3DDECLUSAGE_BLENDWEIGHT;
00520             break;
00521         case VES_DIFFUSE:
00522             return D3DDECLUSAGE_COLOR; // NB index will differentiate
00523             break;
00524         case VES_SPECULAR:
00525             return D3DDECLUSAGE_COLOR; // NB index will differentiate
00526             break;
00527         case VES_NORMAL:
00528             return D3DDECLUSAGE_NORMAL;
00529             break;
00530         case VES_POSITION:
00531             return D3DDECLUSAGE_POSITION;
00532             break;
00533         case VES_TEXTURE_COORDINATES:
00534             return D3DDECLUSAGE_TEXCOORD;
00535             break;
00536         case VES_BINORMAL:
00537             return D3DDECLUSAGE_BINORMAL;
00538             break;
00539         case VES_TANGENT:
00540             return D3DDECLUSAGE_TANGENT;
00541             break;
00542         }
00543         // to keep compiler happy
00544         return D3DDECLUSAGE_POSITION;
00545     }
00546     //---------------------------------------------------------------------
00547     D3DXMATRIX D3D9Mappings::makeD3DXMatrix( const Matrix4& mat )
00548     {
00549         // Transpose matrix
00550         // D3D9 uses row vectors i.e. V*M
00551         // Ogre, OpenGL and everything else uses column vectors i.e. M*V
00552         D3DXMATRIX d3dMat;
00553         d3dMat.m[0][0] = mat[0][0];
00554         d3dMat.m[0][1] = mat[1][0];
00555         d3dMat.m[0][2] = mat[2][0];
00556         d3dMat.m[0][3] = mat[3][0];
00557 
00558         d3dMat.m[1][0] = mat[0][1];
00559         d3dMat.m[1][1] = mat[1][1];
00560         d3dMat.m[1][2] = mat[2][1];
00561         d3dMat.m[1][3] = mat[3][1];
00562 
00563         d3dMat.m[2][0] = mat[0][2];
00564         d3dMat.m[2][1] = mat[1][2];
00565         d3dMat.m[2][2] = mat[2][2];
00566         d3dMat.m[2][3] = mat[3][2];
00567 
00568         d3dMat.m[3][0] = mat[0][3];
00569         d3dMat.m[3][1] = mat[1][3];
00570         d3dMat.m[3][2] = mat[2][3];
00571         d3dMat.m[3][3] = mat[3][3];
00572 
00573         return d3dMat;
00574     }
00575     //---------------------------------------------------------------------
00576     Matrix4 D3D9Mappings::convertD3DXMatrix( const D3DXMATRIX& mat )
00577     {
00578         Matrix4 ogreMat;
00579         ogreMat[0][0] = mat.m[0][0];
00580         ogreMat[1][0] = mat.m[0][1];
00581         ogreMat[2][0] = mat.m[0][2];
00582         ogreMat[3][0] = mat.m[0][3];
00583 
00584         ogreMat[0][1] = mat.m[1][0];
00585         ogreMat[1][1] = mat.m[1][1];
00586         ogreMat[2][1] = mat.m[1][2];
00587         ogreMat[3][1] = mat.m[1][3];
00588 
00589         ogreMat[0][2] = mat.m[2][0];
00590         ogreMat[1][2] = mat.m[2][1];
00591         ogreMat[2][2] = mat.m[2][2];
00592         ogreMat[3][2] = mat.m[2][3];
00593 
00594         ogreMat[0][3] = mat.m[3][0];
00595         ogreMat[1][3] = mat.m[3][1];
00596         ogreMat[2][3] = mat.m[3][2];
00597         ogreMat[3][3] = mat.m[3][3];
00598 
00599         return ogreMat;
00600     }
00601 
00602 
00603 }

Copyright © 2002-2003 by The OGRE Team
Last modified Fri May 14 23:22:02 2004