home *** CD-ROM | disk | FTP | other *** search
/ Programming a Multiplayer FPS in DirectX / Programming a Multiplayer FPS in DirectX (Companion CD).iso / DirectX / dxsdk_oct2004.exe / dxsdk.exe / Samples / C++ / Common / DXUTEffectMap.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2004-09-28  |  24.6 KB  |  544 lines
  1. //-----------------------------------------------------------------------------
  2. // File: DXUTEffectMap.cpp
  3. //
  4. // Desc: Maps the set of standard semantics and annotations to a collection
  5. //       of ID3DXEffect objects. 
  6. //
  7. // Copyright (c) Microsoft Corporation. All rights reserved.
  8. //-----------------------------------------------------------------------------
  9. #include "dxstdafx.h"
  10.  
  11.  
  12.  
  13. //-------------------------------------------------------------------------------------
  14. DXUT_SEMANTIC CDXUTEffectMap::StringToSemantic( const char* cstrSemantic )
  15. {
  16.     char strSemantic[MAX_PATH+1] = {0};
  17.     RemoveTrailingNumber( strSemantic, MAX_PATH, cstrSemantic );
  18.  
  19.     if( StringEquals( strSemantic, "Diffuse" ) )                               return DXUT_Diffuse;
  20.     if( StringEquals( strSemantic, "Specular" ) )                              return DXUT_Specular;
  21.     if( StringEquals( strSemantic, "Ambient" ) )                               return DXUT_Ambient;
  22.     if( StringEquals( strSemantic, "SpecularPower" ) )                         return DXUT_SpecularPower;
  23.     if( StringEquals( strSemantic, "Emissive" ) )                              return DXUT_Emissive;
  24.     if( StringEquals( strSemantic, "Normal" ) )                                return DXUT_Normal;
  25.     if( StringEquals( strSemantic, "Height" ) )                                return DXUT_Height;
  26.     if( StringEquals( strSemantic, "Refraction" ) )                            return DXUT_Refraction;
  27.     if( StringEquals( strSemantic, "Opacity" ) )                               return DXUT_Opacity;
  28.     if( StringEquals( strSemantic, "Environment" ) )                           return DXUT_Environment;
  29.     if( StringEquals( strSemantic, "EnvironmentNormal" ) )                     return DXUT_EnvironmentNormal;
  30.     if( StringEquals( strSemantic, "Fresnel" ) )                               return DXUT_Fresnel;
  31.     
  32.     if( StringEquals( strSemantic, "World" ) )                                 return DXUT_World;
  33.     if( StringEquals( strSemantic, "WorldInverse" ) )                          return DXUT_WorldInverse;
  34.     if( StringEquals( strSemantic, "WorldInverseTranspose" ) )                 return DXUT_WorldInverseTranspose;
  35.     if( StringEquals( strSemantic, "WorldView" ) )                             return DXUT_WorldView;
  36.     if( StringEquals( strSemantic, "WorldViewInverse" ) )                      return DXUT_WorldViewInverse;
  37.     if( StringEquals( strSemantic, "WorldViewInverseTranspose" ) )             return DXUT_WorldViewInverseTranspose;
  38.     if( StringEquals( strSemantic, "WorldViewProjection" ) )                   return DXUT_WorldViewProjection;
  39.     if( StringEquals( strSemantic, "WorldViewProjectionInverse" ) )            return DXUT_WorldViewProjectionInverse;
  40.     if( StringEquals( strSemantic, "WorldViewProjectionInverseTranspose" ) )   return DXUT_WorldViewProjectionInverseTranspose;
  41.     if( StringEquals( strSemantic, "View" ) )                                  return DXUT_View;
  42.     if( StringEquals( strSemantic, "ViewInverse" ) )                           return DXUT_ViewInverse;
  43.     if( StringEquals( strSemantic, "ViewInverseTranspose" ) )                  return DXUT_ViewInverseTranspose;
  44.     if( StringEquals( strSemantic, "ViewProjection" ) )                        return DXUT_ViewProjection;
  45.     if( StringEquals( strSemantic, "ViewProjectionInverse" ) )                 return DXUT_ViewProjectionInverse;
  46.     if( StringEquals( strSemantic, "ViewProjectionInverseTranspose" ) )        return DXUT_ViewProjectionInverseTranspose;
  47.     if( StringEquals( strSemantic, "Projection" ) )                            return DXUT_Projection;
  48.     if( StringEquals( strSemantic, "ProjectionInverse" ) )                     return DXUT_ProjectionInverse;
  49.     if( StringEquals( strSemantic, "ProjectionInverseTranspose" ) )            return DXUT_ProjectionInverseTranspose;
  50.  
  51.     if( StringEquals( strSemantic, "RenderTargetDimensions" ) )                return DXUT_RenderTargetDimensions;
  52.     if( StringEquals( strSemantic, "RenderTargetClipping" ) )                  return DXUT_RenderTargetClipping;
  53.     if( StringEquals( strSemantic, "Time" ) )                                  return DXUT_Time;
  54.     if( StringEquals( strSemantic, "LastTime" ) )                              return DXUT_LastTime;
  55.     if( StringEquals( strSemantic, "ElapsedTime" ) )                           return DXUT_ElapsedTime;
  56.     if( StringEquals( strSemantic, "Position" ) )                              return DXUT_Position;
  57.     if( StringEquals( strSemantic, "Direction" ) )                             return DXUT_Direction;
  58.     if( StringEquals( strSemantic, "BoundingCenter" ) )                        return DXUT_BoundingCenter;
  59.     if( StringEquals( strSemantic, "BoundingSphereSize" ) )                    return DXUT_BoundingSphereSize;
  60.     if( StringEquals( strSemantic, "BoundingSphereMin" ) )                     return DXUT_BoundingSphereMin;
  61.     if( StringEquals( strSemantic, "BoundingSphereMax" ) )                     return DXUT_BoundingSphereMax;
  62.     if( StringEquals( strSemantic, "BoundingBoxSize" ) )                       return DXUT_BoundingBoxSize;
  63.     if( StringEquals( strSemantic, "BoundingBoxMin" ) )                        return DXUT_BoundingBoxMin;
  64.     if( StringEquals( strSemantic, "BoundingBoxMax" ) )                        return DXUT_BoundingBoxMax;
  65.     if( StringEquals( strSemantic, "Attenuation" ) )                           return DXUT_Attenuation;
  66.     if( StringEquals( strSemantic, "RenderColorTarget" ) )                     return DXUT_RenderColorTarget;
  67.     if( StringEquals( strSemantic, "RenderDepthStencilTarget" ) )              return DXUT_RenderDepthStencilTarget;
  68.     if( StringEquals( strSemantic, "UnitsScale" ) )                            return DXUT_UnitsScale;
  69.     if( StringEquals( strSemantic, "StandardsGlobal" ) )                       return DXUT_StandardsGlobal;
  70.         
  71.     return DXUT_UNKNOWN_SEMANTIC;
  72. }
  73.  
  74.  
  75. //-------------------------------------------------------------------------------------
  76. DXUT_SEMANTIC CDXUTEffectMap::StringToSemantic( const WCHAR* strSemantic )
  77. {
  78.     char cstr[MAX_PATH+1] = {0};
  79.     WideCharToMultiByte( CP_ACP, 0, strSemantic, -1, cstr, MAX_PATH, NULL, NULL );
  80.     return StringToSemantic( cstr );
  81. }
  82.  
  83.  
  84. //-------------------------------------------------------------------------------------
  85. DXUT_OBJECT CDXUTEffectMap::StringToObject( const char* cstrObject )
  86. {
  87.     char strObject[MAX_PATH+1] = {0};
  88.     RemoveTrailingNumber( strObject, MAX_PATH, cstrObject );
  89.  
  90.     if( StringEquals( strObject, "Geometry" ) )  return DXUT_Geometry;
  91.     if( StringEquals( strObject, "Light" ) )     return DXUT_Light;
  92.     if( StringEquals( strObject, "Camera" ) )    return DXUT_Camera;
  93.     if( StringEquals( strObject, "Frame" ) )     return DXUT_Frame;
  94.     
  95.     return DXUT_UNKNOWN_OBJECT;
  96. }
  97.  
  98.  
  99. //-------------------------------------------------------------------------------------
  100. DXUT_OBJECT CDXUTEffectMap::StringToObject( const WCHAR* strObject )
  101. {
  102.     char cstr[MAX_PATH+1] = {0};
  103.     WideCharToMultiByte( CP_ACP, 0, strObject, -1, cstr, MAX_PATH, NULL, NULL );
  104.     return StringToObject( cstr );
  105. }
  106.  
  107.  
  108. //-------------------------------------------------------------------------------------
  109. VOID CDXUTEffectMap::Reset()
  110. {
  111.     D3DXMatrixIdentity( &m_matWorld );
  112.     D3DXMatrixIdentity( &m_matView );
  113.     D3DXMatrixIdentity( &m_matProjection );
  114.  
  115.     // Reset all the stored parameter lists
  116.     for( UINT iSemantic = 0; iSemantic < NUM_DXUT_SEMANTICS; iSemantic++ )
  117.     {
  118.         for( UINT iObject = 0; iObject < NUM_DXUT_OBJECTS; iObject++ )
  119.         {
  120.             for( UINT iIndex = 0; iIndex < MAX_INDEX; iIndex++ )
  121.             {
  122.                 CGrowableArray<ParamList>* pBinding = &m_Bindings[ iSemantic ][ iObject ][ iIndex ];
  123.  
  124.                 // Clear nested arrays first
  125.                 for( int iParamList = 0; iParamList < pBinding->GetSize(); iParamList++ )
  126.                 {
  127.                     pBinding->GetAt( iParamList ).Reset();
  128.                 }
  129.                 
  130.                 // Remove all the bound parameter lists
  131.                 pBinding->RemoveAll();
  132.             }
  133.         }
  134.     }
  135. }
  136.  
  137.  
  138. //-------------------------------------------------------------------------------------
  139. HRESULT CDXUTEffectMap::SetStandardParameter( const WCHAR* strSemantic, 
  140.                                          const WCHAR* strObject, 
  141.                                          DWORD dwObjectIndex, 
  142.                                          float* pData, 
  143.                                          DWORD dwDataLen, 
  144.                                          const WCHAR* strType, 
  145.                                          const WCHAR* strUnits, 
  146.                                          const WCHAR* strSpace )
  147. {
  148.     // Map the semantic to the standard set
  149.     DXUT_SEMANTIC eSemantic = StringToSemantic( strSemantic );
  150.     if( eSemantic == DXUT_UNKNOWN_SEMANTIC )
  151.         return E_FAIL;
  152.  
  153.     // Map the object to the standard set
  154.     DXUT_OBJECT eObject = StringToObject( strObject );
  155.     if( eObject == DXUT_UNKNOWN_OBJECT )
  156.         return E_FAIL;  
  157.  
  158.     return SetStandardParameter( eSemantic, eObject, dwObjectIndex, pData, dwDataLen, strType, strUnits, strSpace );
  159. }
  160.  
  161.  
  162. //-------------------------------------------------------------------------------------
  163. HRESULT CDXUTEffectMap::SetStandardParameter( DXUT_SEMANTIC eSemantic, 
  164.                                          DXUT_OBJECT eObject, 
  165.                                          DWORD dwObjectIndex, 
  166.                                          float* pData, 
  167.                                          DWORD dwDataLen, 
  168.                                          const WCHAR* strType, 
  169.                                          const WCHAR* strUnits, 
  170.                                          const WCHAR* strSpace )
  171. {
  172.     HRESULT hr;
  173.  
  174.     // TODO: remove index limits
  175.     if( dwObjectIndex >= MAX_INDEX )
  176.         return E_INVALIDARG;
  177.  
  178.     // TODO: handle unit and space conversions
  179.  
  180.     // Retrieve the interested handles
  181.     CGrowableArray<ParamList>* pBindings = &m_Bindings[ eSemantic ][ eObject ][ dwObjectIndex ];
  182.         
  183.     for( int iList=0; iList < pBindings->GetSize(); iList++ )
  184.     {
  185.         ParamList& paramList = pBindings->GetAt(iList);
  186.  
  187.         for( int iParam=0; iParam < paramList.ahParameters.GetSize(); iParam++ )
  188.         {
  189.             V_RETURN( paramList.pEffect->SetFloatArray( paramList.ahParameters[iParam], pData, dwDataLen ) );
  190.         }
  191.     }
  192.  
  193.     return S_OK;
  194. }
  195.  
  196. void ParamList::Reset() 
  197. { 
  198.     SAFE_RELEASE(pEffect); 
  199.     ahParameters.RemoveAll(); 
  200. }
  201.  
  202.  
  203. //-------------------------------------------------------------------------------------
  204. // Investigates all the parameters, looking at semantics and annotations and placing 
  205. // handles to these parameters within the internal database.
  206. //-------------------------------------------------------------------------------------
  207. HRESULT CDXUTEffectMap::AddEffect( ID3DXEffect* pEffect )
  208. {
  209.     HRESULT hr;
  210.  
  211.     if( pEffect == NULL )
  212.         return E_INVALIDARG;
  213.  
  214.     // Get the number of parameters
  215.     D3DXEFFECT_DESC descEffect;
  216.     V_RETURN( pEffect->GetDesc( &descEffect ) );
  217.     
  218.     // Enumerate the parameters
  219.     for( UINT iParam=0; iParam < descEffect.Parameters; iParam++ )
  220.     {
  221.         // Retrieve param
  222.         D3DXHANDLE hParameter = pEffect->GetParameter( NULL, iParam );
  223.         if( NULL == hParameter )
  224.             return E_FAIL;
  225.  
  226.         // Grab description
  227.         D3DXPARAMETER_DESC desc;
  228.         V_RETURN( pEffect->GetParameterDesc( hParameter, &desc ) );
  229.  
  230.         // If this parameter doesn't have a semantic, skip to the next parameter
  231.         if( desc.Semantic == NULL )
  232.             continue;
  233.  
  234.         // Map the semantic to the standard set
  235.         DXUT_SEMANTIC eSemantic = StringToSemantic( desc.Semantic );
  236.         if( eSemantic == DXUT_UNKNOWN_SEMANTIC )
  237.             continue;
  238.  
  239.         // Get the object annotation
  240.         const char* cstrObject = "Geometry";
  241.         D3DXHANDLE hAnnotation = pEffect->GetAnnotationByName( hParameter, "Object" );
  242.         if( hAnnotation )
  243.         {
  244.             V_RETURN( pEffect->GetString( hAnnotation, &cstrObject ) );
  245.         }
  246.  
  247.         // Map the object to the standard set
  248.         DXUT_OBJECT eObject = StringToObject( cstrObject );
  249.         if( eObject == DXUT_UNKNOWN_OBJECT )
  250.             continue;
  251.  
  252.         // Extract the index from the semantic
  253.         int index = 0;
  254.         const char* strIndex = desc.Semantic + strlen(desc.Semantic)-1;
  255.  
  256.         // If there is a digit at the end of the semantic, locate the beginning of the index
  257.         // and convert to an integer
  258.         if( isdigit( (BYTE) (*strIndex) ) )
  259.         {
  260.             while( isdigit( (BYTE) (*(strIndex-1)) ) )
  261.             {
  262.                 --strIndex;
  263.             }
  264.  
  265.             index = atoi( strIndex );
  266.         }
  267.  
  268.         // Check whether index is out of bounds
  269.         if( index < 0 || index >= MAX_INDEX )
  270.             continue;
  271.  
  272.         // Store the handle
  273.         CGrowableArray<ParamList>* pBindings = &m_Bindings[ eSemantic ][ eObject ][ index ];
  274.         
  275.         bool bBound = false;
  276.         for( int i=0; i < pBindings->GetSize(); i++ )
  277.         {
  278.             if( pBindings->GetAt(i).pEffect == pEffect )
  279.             {
  280.                 // Found the containing effect for this parameter in the list, add the new handle
  281.                 pBindings->GetAt(i).ahParameters.Add( hParameter );
  282.                 bBound = true;
  283.                 break;
  284.             }
  285.         }
  286.  
  287.         if( !bBound )
  288.         {
  289.             // This parameter belongs to a new effect
  290.             ParamList newParamList;
  291.             newParamList.pEffect = pEffect;
  292.             pEffect->AddRef();
  293.             newParamList.ahParameters.Add( hParameter );
  294.             pBindings->Add( newParamList );
  295.         }
  296.        
  297.     }
  298.     
  299.     return S_OK;
  300. }
  301.  
  302.  
  303. //-------------------------------------------------------------------------------------
  304. // Removes all instances of this effect from the binding list
  305. //-------------------------------------------------------------------------------------
  306. HRESULT CDXUTEffectMap::RemoveEffect( ID3DXEffect* pEffect )
  307. {
  308.     if( pEffect == NULL )
  309.         return E_INVALIDARG;
  310.  
  311.     // Search through the list of registered semantics and remove all items
  312.     // assigned to the given effect
  313.     for( UINT iSemantic = 0; iSemantic < NUM_DXUT_SEMANTICS; iSemantic++ )
  314.     {
  315.         for( UINT iObject = 0; iObject < NUM_DXUT_OBJECTS; iObject++ )
  316.         {
  317.             for( UINT iIndex = 0; iIndex < MAX_INDEX; iIndex++ )
  318.             {
  319.                 CGrowableArray<ParamList>* pBinding = &m_Bindings[ iSemantic ][ iObject ][ iIndex ];
  320.  
  321.                 // Clear nested arrays first
  322.                 for( int iParamList = 0; iParamList < pBinding->GetSize(); iParamList++ )
  323.                 {
  324.                     ParamList& rParamList = pBinding->GetAt( iParamList );
  325.  
  326.                     if( rParamList.pEffect == pEffect )
  327.                         rParamList.Reset();
  328.                 }
  329.             }
  330.         }
  331.     }
  332.  
  333.     return S_OK;
  334. }
  335.  
  336.  
  337. //-------------------------------------------------------------------------------------
  338. HRESULT CDXUTEffectMap::SetWorldMatrix( D3DXMATRIXA16* pWorldMatrix, const WCHAR* strUnits )
  339. {
  340.     m_matWorld = *pWorldMatrix;
  341.     return UpdateTransforms( DXUT_World );
  342. }
  343.  
  344.  
  345. //-------------------------------------------------------------------------------------
  346. HRESULT CDXUTEffectMap::SetViewMatrix( D3DXMATRIXA16* pViewMatrix, const WCHAR* strUnits )
  347. {
  348.     m_matView = *pViewMatrix;
  349.     return UpdateTransforms( DXUT_View );
  350. }
  351.  
  352.  
  353. //-------------------------------------------------------------------------------------
  354. HRESULT CDXUTEffectMap::SetProjectionMatrix( D3DXMATRIXA16* pProjectionMatrix )
  355. {
  356.     m_matProjection = *pProjectionMatrix;
  357.     return UpdateTransforms( DXUT_Projection );
  358. }
  359.  
  360.  
  361. //-------------------------------------------------------------------------------------
  362. HRESULT CDXUTEffectMap::UpdateTransforms( DXUT_SEMANTIC eSemantic, const WCHAR* strUnits )
  363. {
  364.     HRESULT hr;
  365.  
  366.     // Determine which transforms are required by the effect
  367.     bool bEffectContains[ NUM_DXUT_SEMANTICS ] = {0};
  368.     for( int iTransform = DXUT_World; iTransform <= DXUT_ProjectionInverseTranspose; iTransform++ )
  369.     {
  370.         bEffectContains[iTransform] = ( m_Bindings[ iTransform ][ DXUT_Geometry ][ 0 ].GetSize() > 0 );
  371.     }
  372.  
  373.     if( eSemantic == DXUT_World )
  374.     {
  375.         // World matrix permutations
  376.         if( bEffectContains[ DXUT_World ] ||
  377.             bEffectContains[ DXUT_WorldInverse ] ||
  378.             bEffectContains[ DXUT_WorldInverseTranspose ] )
  379.         {
  380.             V_RETURN( SetStandardParameter( DXUT_World, DXUT_Geometry, 0, (float*)&m_matWorld, 16, L"", strUnits, L"World" ) );
  381.  
  382.             if( bEffectContains[ DXUT_WorldInverse ] ||
  383.                 bEffectContains[ DXUT_WorldInverseTranspose ] )
  384.             {
  385.                 D3DXMATRIXA16 matWorldInverse;
  386.                 D3DXMatrixInverse( &matWorldInverse, NULL, &m_matWorld );
  387.                 V_RETURN( SetStandardParameter( DXUT_WorldInverse, DXUT_Geometry, 0, (float*)&matWorldInverse, 16, L"", strUnits, L"World" ) );
  388.             
  389.                 if( bEffectContains[ DXUT_WorldInverseTranspose ] )
  390.                 {
  391.                     D3DXMATRIXA16 matWorldInverseTranspose;
  392.                     D3DXMatrixTranspose( &matWorldInverseTranspose, &matWorldInverse );
  393.                     V_RETURN( SetStandardParameter( DXUT_WorldInverseTranspose, DXUT_Geometry, 0, (float*)&matWorldInverseTranspose, 16, L"", strUnits, L"World" ) );
  394.                 }
  395.             }
  396.         }
  397.     }
  398.  
  399.     if( eSemantic == DXUT_World ||
  400.         eSemantic == DXUT_View )
  401.     {
  402.         // WorldView matrix permutations
  403.         if( bEffectContains[ DXUT_WorldView ] ||
  404.             bEffectContains[ DXUT_WorldViewInverse ] ||
  405.             bEffectContains[ DXUT_WorldViewInverseTranspose ] )
  406.         {
  407.             D3DXMATRIXA16 matWorldView;
  408.             D3DXMatrixMultiply( &matWorldView, &m_matWorld, &m_matView );
  409.             V_RETURN( SetStandardParameter( DXUT_WorldView, DXUT_Geometry, 0, (float*)&matWorldView, 16, L"", strUnits, L"World" ) );
  410.         
  411.             if( bEffectContains[ DXUT_WorldViewInverse ] ||
  412.                 bEffectContains[ DXUT_WorldViewInverseTranspose ] )
  413.             {
  414.                 D3DXMATRIXA16 matWorldViewInverse;
  415.                 D3DXMatrixInverse( &matWorldViewInverse, NULL, &matWorldView );    
  416.                 V_RETURN( SetStandardParameter( DXUT_WorldViewInverse, DXUT_Geometry, 0, (float*)&matWorldViewInverse, 16, L"", strUnits, L"World" ) );
  417.             
  418.                 if( bEffectContains[ DXUT_WorldViewInverseTranspose ] )
  419.                 {
  420.                     D3DXMATRIXA16 matWorldViewInverseTranspose;
  421.                     D3DXMatrixTranspose( &matWorldViewInverseTranspose, &matWorldViewInverse );
  422.                     V_RETURN( SetStandardParameter( DXUT_WorldViewInverseTranspose, DXUT_Geometry, 0, (float*)&matWorldViewInverseTranspose, 16, L"", strUnits, L"World" ) );
  423.                 }
  424.             }
  425.         }
  426.     }
  427.  
  428.     if( eSemantic == DXUT_World ||
  429.         eSemantic == DXUT_View ||
  430.         eSemantic == DXUT_Projection )
  431.     {
  432.         // WorldViewProjection matrix permutations
  433.         if( bEffectContains[ DXUT_WorldViewProjection ] ||
  434.             bEffectContains[ DXUT_WorldViewProjectionInverse ] ||
  435.             bEffectContains[ DXUT_WorldViewProjectionInverseTranspose ] )
  436.         {
  437.             D3DXMATRIXA16 matWorldViewProjection;
  438.             D3DXMatrixMultiply( &matWorldViewProjection, &m_matWorld, &m_matView );
  439.             D3DXMatrixMultiply( &matWorldViewProjection, &matWorldViewProjection, &m_matProjection );
  440.  
  441.             V_RETURN( SetStandardParameter( DXUT_WorldViewProjection, DXUT_Geometry, 0, (float*)&matWorldViewProjection, 16, L"", strUnits, L"World" ) );
  442.         
  443.             if( bEffectContains[ DXUT_WorldViewProjectionInverse ] ||
  444.                 bEffectContains[ DXUT_WorldViewProjectionInverseTranspose ] )
  445.             {
  446.                 D3DXMATRIXA16 matWorldViewProjectionInverse;
  447.                 D3DXMatrixInverse( &matWorldViewProjectionInverse, NULL, &matWorldViewProjection );    
  448.                 V_RETURN( SetStandardParameter( DXUT_WorldViewProjectionInverse, DXUT_Geometry, 0, (float*)&matWorldViewProjectionInverse, 16, L"", strUnits, L"World" ) );
  449.             
  450.                 if( bEffectContains[ DXUT_WorldViewProjectionInverseTranspose ] )
  451.                 {
  452.                     D3DXMATRIXA16 matWorldViewProjectionInverseTranspose;
  453.                     D3DXMatrixTranspose( &matWorldViewProjectionInverseTranspose, &matWorldViewProjectionInverse );
  454.                     V_RETURN( SetStandardParameter( DXUT_WorldViewProjectionInverseTranspose, DXUT_Geometry, 0, (float*)&matWorldViewProjectionInverseTranspose, 16, L"", strUnits, L"World" ) );
  455.                 }
  456.             }
  457.         }
  458.     }
  459.  
  460.     if( eSemantic == DXUT_View )
  461.     {
  462.         // View matrix permutations
  463.         if( bEffectContains[ DXUT_View ] ||
  464.             bEffectContains[ DXUT_ViewInverse ] ||
  465.             bEffectContains[ DXUT_ViewInverseTranspose ] )
  466.         {
  467.             V_RETURN( SetStandardParameter( DXUT_View, DXUT_Geometry, 0, (float*)&m_matView, 16, L"", strUnits, L"World" ) );
  468.  
  469.             if( bEffectContains[ DXUT_ViewInverse ] ||
  470.                 bEffectContains[ DXUT_ViewInverseTranspose ] )
  471.             {
  472.                 D3DXMATRIXA16 matViewInverse;
  473.                 D3DXMatrixInverse( &matViewInverse, NULL, &m_matView );
  474.                 V_RETURN( SetStandardParameter( DXUT_ViewInverse, DXUT_Geometry, 0, (float*)&matViewInverse, 16, L"", strUnits, L"World" ) );
  475.             
  476.                 if( bEffectContains[ DXUT_ViewInverseTranspose ] )
  477.                 {
  478.                     D3DXMATRIXA16 matViewInverseTranspose;
  479.                     D3DXMatrixTranspose( &matViewInverseTranspose, &matViewInverse );
  480.                     V_RETURN( SetStandardParameter( DXUT_ViewInverseTranspose, DXUT_Geometry, 0, (float*)&matViewInverseTranspose, 16, L"", strUnits, L"World" ) );
  481.                 }
  482.             }
  483.         }
  484.     }
  485.  
  486.     if( eSemantic == DXUT_View ||
  487.         eSemantic == DXUT_Projection )
  488.     {
  489.         // ViewProjection matrix permutations
  490.         if( bEffectContains[ DXUT_ViewProjection ] ||
  491.             bEffectContains[ DXUT_ViewProjectionInverse ] ||
  492.             bEffectContains[ DXUT_ViewProjectionInverseTranspose ] )
  493.         {
  494.             D3DXMATRIXA16 matViewProjection;
  495.             D3DXMatrixMultiply( &matViewProjection, &m_matView, &m_matProjection );
  496.             V_RETURN( SetStandardParameter( DXUT_ViewProjection, DXUT_Geometry, 0, (float*)&matViewProjection, 16, L"", strUnits, L"World" ) );
  497.         
  498.             if( bEffectContains[ DXUT_ViewProjectionInverse ] ||
  499.                 bEffectContains[ DXUT_ViewProjectionInverseTranspose ] )
  500.             {
  501.                 D3DXMATRIXA16 matViewProjectionInverse;
  502.                 D3DXMatrixInverse( &matViewProjectionInverse, NULL, &matViewProjection );    
  503.                 V_RETURN( SetStandardParameter( DXUT_ViewProjectionInverse, DXUT_Geometry, 0, (float*)&matViewProjectionInverse, 16, L"", strUnits, L"World" ) );
  504.             
  505.                 if( bEffectContains[ DXUT_ViewProjectionInverseTranspose ] )
  506.                 {
  507.                     D3DXMATRIXA16 matViewProjectionInverseTranspose;
  508.                     D3DXMatrixTranspose( &matViewProjectionInverseTranspose, &matViewProjectionInverse );
  509.                     V_RETURN( SetStandardParameter( DXUT_ViewProjectionInverseTranspose, DXUT_Geometry, 0, (float*)&matViewProjectionInverseTranspose, 16, L"", strUnits, L"World" ) );
  510.                 }
  511.             }
  512.         }
  513.     }
  514.  
  515.     if( eSemantic == DXUT_Projection )
  516.     {
  517.         // Projection matrix permutations
  518.         if( bEffectContains[ DXUT_Projection ] ||
  519.             bEffectContains[ DXUT_ProjectionInverse ] ||
  520.             bEffectContains[ DXUT_ProjectionInverseTranspose ] )
  521.         {
  522.             V_RETURN( SetStandardParameter( DXUT_Projection, DXUT_Geometry, 0, (float*)&m_matProjection, 16, L"", strUnits, L"World" ) );
  523.  
  524.             if( bEffectContains[ DXUT_ProjectionInverse ] ||
  525.                 bEffectContains[ DXUT_ProjectionInverseTranspose ] )
  526.             {
  527.                 D3DXMATRIXA16 matProjectionInverse;
  528.                 D3DXMatrixInverse( &matProjectionInverse, NULL, &m_matProjection );
  529.                 V_RETURN( SetStandardParameter( DXUT_ProjectionInverse, DXUT_Geometry, 0, (float*)&matProjectionInverse, 16, L"", strUnits, L"World" ) );
  530.             
  531.                 if( bEffectContains[ DXUT_ProjectionInverseTranspose ] )
  532.                 {
  533.                     D3DXMATRIXA16 matProjectionInverseTranspose;
  534.                     D3DXMatrixTranspose( &matProjectionInverseTranspose, &matProjectionInverse );
  535.                     V_RETURN( SetStandardParameter( DXUT_ProjectionInverseTranspose, DXUT_Geometry, 0, (float*)&matProjectionInverseTranspose, 16, L"", strUnits, L"World" ) );
  536.                 }
  537.             }
  538.         }
  539.     }
  540.  
  541.     return S_OK;
  542. }
  543.  
  544.