开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
TerrainMesh.cpp
资源名称：Visual_C++GameDevelop.rar　[点击查看]
上传用户：sycq158
上传日期：2008-10-22
资源大小：15361k
文件大小：42k
源码类别：

游戏

开发平台：

Visual C++

TerrainMesh.cpp：源码内容
  1. //-----------------------------------------------------------------------------
  2. // File: terrainmesh.cpp
  3. //
  4. // Copyright (C) Microsoft Corporation. All Rights Reserved.
  5. //-----------------------------------------------------------------------------
  6. #include "stdafx.h"
  8. #define RVALUE(rgb)      ((BYTE)((rgb)>>16))
  9. #define GVALUE(rgb)      ((BYTE)(((WORD)(rgb)) >> 8))
  10. #define BVALUE(rgb)      ((BYTE)(rgb))
  13. extern CProfile g_Profile;
  18. //-----------------------------------------------------------------------------
  19. // Name: 
  20. // Desc: 
  21. //-----------------------------------------------------------------------------
  22. CTerrainMesh::CTerrainMesh( CTerrainEngine* pTerrainEngine )
  23. {
  24.     g_pTerrainEngine = pTerrainEngine;
  25.     m_pMesh         = NULL;
  26.     m_pMap          = NULL;
  27.     m_pTexture      = NULL;
  28.     m_dwNumFaces    = 0;
  29.     m_dwNumVerties  = 0;
  30. }
  35. //-----------------------------------------------------------------------------
  36. // Name: 
  37. // Desc: 
  38. //-----------------------------------------------------------------------------
  39. CTerrainMesh::~CTerrainMesh()
  40. {
  41.     FinalCleanup();
  42. }
  47. //-----------------------------------------------------------------------------
  48. // Name: 
  49. // Desc: 
  50. //-----------------------------------------------------------------------------
  51. HRESULT CTerrainMesh::OneTimeSceneInit( CZoneStyleParameter* pLandStyle, const float fWorldOffsetX, const float fWorldOffsetZ, CTerrainMesh* pNorth, CTerrainMesh* pEast, CTerrainMesh* pNorthEast )
  52. {
  53.     m_pLandStyle = pLandStyle;
  55.     m_pMap = new CHeightMap( g_pTerrainEngine, fWorldOffsetX, fWorldOffsetZ );
  56.     if( m_pMap == NULL )
  57.         return E_OUTOFMEMORY;
  59.     m_pNorth    = pNorth;
  60.     m_pEast     = pEast;
  61.     m_pNorthEast = pNorthEast;
  62.     m_fWorldOffsetX  = fWorldOffsetX;
  63.     m_fWorldOffsetZ  = fWorldOffsetZ;
  65.     return S_OK;
  66. }
  71. //-----------------------------------------------------------------------------
  72. // Name: 
  73. // Desc: 
  74. //-----------------------------------------------------------------------------
  75. HRESULT CTerrainMesh::InitDeviceObjects( D3DFORMAT fmtTexture )
  76. {
  77.     HRESULT hr;
  78.     m_fmtTexture = fmtTexture;
  80.     // Create height map using one of the following methods
  81.     if( m_pLandStyle->HeightCreationType == HCT_FromFile )
  82.     {
  83.         TCHAR strFile[MAX_PATH];
  84.         CMyApplication::FindMediaFileCch( strFile, MAX_PATH, m_pLandStyle->szHeightMap );
  85.         if( FAILED( hr = m_pMap->CreateFromFile( strFile ) ) )
  86.         {
  87.             g_pApp->CleanupAndDisplayError( DONUTSERR_ARTLOADFAILED, m_pLandStyle->szHeightMap, strFile );
  88.             return DXTRACE_ERR( TEXT("CreateFromFile"), hr );;
  89.         }
  90.     }
  91.     else 
  92.     {
  93.         m_pMap->Create( ZONE_WIDTH, ZONE_HEIGHT );
  94.         if( m_pLandStyle->HeightCreationType == HCT_CreateTest )
  95.         {
  96. //            m_pMap->CreateTestMap( 0.0f );
  97. //            m_pMap->CreateSmallHills();
  98.         }
  99.     }
  101.     return S_OK;
  102. }
  107. //-----------------------------------------------------------------------------
  108. // Name: 
  109. // Desc: 
  110. //-----------------------------------------------------------------------------
  111. FLOAT CTerrainMesh::TextureColorFactor( DWORD iTexture, float fValue )
  112. {
  113.     float fHigh, fMid, fLow;
  115.     fMid = m_pLandStyle->aLayerHeight[iTexture];
  117.     if( iTexture==0 )
  118.         fLow = -0.25f;
  119.     else
  120.         fLow = m_pLandStyle->aLayerHeight[iTexture-1];
  122.     if( iTexture==m_pLandStyle->dwNumLayers-1 )
  123.         fHigh = 1.25f;
  124.     else
  125.         fHigh = m_pLandStyle->aLayerHeight[iTexture+1];
  127.     if( fValue > fHigh || fValue < fLow )
  128.         return 0.0f;
  130.     float fPercent;
  131.     if( fValue > fMid )
  132.         fPercent = (fHigh - fValue) / (fHigh - fMid);
  133.     else
  134.         fPercent = (fValue - fLow) / (fMid - fLow); 
  136.     return fPercent;
  137. }
  142. //-----------------------------------------------------------------------------
  143. // Name: 
  144. // Desc: 
  145. //-----------------------------------------------------------------------------
  146. BYTE CTerrainMesh::TextureAlpha( float fHeight, int nIndex )
  147. {
  148.     BYTE aAlpha[MAX_SOURCE_TEXTURES];           
  149.     BYTE aAlpha2[MAX_SOURCE_TEXTURES];           
  150.     int  nTotalAlpha = 0;
  151.     int  nTotalAlpha2 = 0;
  152.     float aFactor[MAX_SOURCE_TEXTURES];
  153.     float aFactor2[MAX_SOURCE_TEXTURES];
  154.     float fTotalFactor = 0.0f;
  155.     DWORD i;
  157.     ZeroMemory( aAlpha, sizeof(BYTE)*MAX_SOURCE_TEXTURES );
  158.     ZeroMemory( aAlpha2, sizeof(BYTE)*MAX_SOURCE_TEXTURES );
  159.     ZeroMemory( aFactor, sizeof(float)*MAX_SOURCE_TEXTURES );
  160.     ZeroMemory( aFactor2, sizeof(float)*MAX_SOURCE_TEXTURES );
  162.     for( i=0; i<m_pLandStyle->dwNumLayers; i++ )
  163.     {
  164.         aFactor[i] = TextureColorFactor( i, fHeight );
  165.         fTotalFactor += aFactor[i];
  166.     }
  168.     for( i=0; i<m_pLandStyle->dwNumLayers; i++ )
  169.         aFactor[i] /= fTotalFactor;
  171.     for( i=0; i<m_pLandStyle->dwNumLayers; i++ )
  172.     {
  173.         aAlpha[i] = (BYTE) (aFactor[i] * (float)0xFF);
  174.         nTotalAlpha += (int) aAlpha[i];
  175.     }
  177.     for( i=0; i<m_pLandStyle->dwNumLayers; i++ )
  178.     {
  179.         aFactor2[i] = (float)aAlpha[i] / (float)nTotalAlpha;
  180.         aAlpha2[i] = (BYTE) ( aFactor2[i] * 0xFF + 0.5f );
  181.         nTotalAlpha2 += aAlpha2[i];
  182.     }
  184.     int nReturn = (int) (aAlpha[nIndex] * m_pLandStyle->fLayerBlendFactor[nIndex] );
  185.     if( nReturn > 0xFF )
  186.         nReturn = 0xFF;
  187.     return (BYTE) nReturn;
  188. }
  193. //-----------------------------------------------------------------------------
  194. // Name: 
  195. // Desc: 
  196. //-----------------------------------------------------------------------------
  197. HRESULT CTerrainMesh::RestoreDeviceObjects( HWND hWndMain )
  198. {
  199.     HRESULT hr;
  201.     int nWidth          = ZONE_WIDTH+1;
  202.     int nHeight         = ZONE_HEIGHT+1;
  204.     // Create texture using one of the following methods
  205.     if( m_pLandStyle->TextureCreationType == TCT_FromFile )
  206.     {
  207.         // Read the texture from a file
  208.         if( FAILED( hr = ReadTextureFromFile( nWidth, nHeight ) ) ) 
  209.             return DXTRACE_ERR( TEXT("ReadTextureFromFile"), hr );
  210.     }
  211.     else if( m_pLandStyle->TextureCreationType == TCT_CreateTest )
  212.     {
  213.         if( FAILED( hr = CreateTestTexture( nWidth, nHeight ) ) ) 
  214.             return DXTRACE_ERR( TEXT("CreateTestTexture"), hr );
  215.     }
  216.     else if( m_pLandStyle->TextureCreationType == TCT_CreateFromHeight )
  217.     {
  218.         // Create the texture based on the height map
  219.         if( FAILED( hr = CreateTextureFromHeight( nWidth, nHeight ) ) ) 
  220.             return DXTRACE_ERR( TEXT("CreateTextureFromHeight"), hr );
  221.     }
  222.     else if( m_pLandStyle->TextureCreationType == TCT_FromLayers )
  223.     {
  224.         if( g_Profile.bLoadFast )
  225.         {
  226.             if( FAILED( hr = CreateTestTexture( nWidth, nHeight ) ) ) 
  227.                 return DXTRACE_ERR( TEXT("CreateTestTexture"), hr );
  228.         }
  229.         else
  230.         {
  231.             // Create the texture by layering a number of detail textures
  232.             if( FAILED( hr = CreateTextureFromLayers( nWidth, nHeight ) ) ) 
  233.                 return DXTRACE_ERR( TEXT("CreateTextureFromLayers"), hr );
  234.         }
  235.     }
  236.     else
  237.     {
  238.         MessageBox( hWndMain, "Unknown texture creation type", "Donuts 4", MB_OK );
  239.         return E_FAIL;
  240.     }
  242.     // Create mesh from the height map
  243.     CreateMeshFromHeightMap( nWidth, nHeight );
  245.     if( m_pLandStyle->bSaveMedia )
  246.     {
  247.         SaveMeshToXFile();
  248.         SaveTextureToFile();
  249.     }
  251.     return S_OK;
  252. }
  257. //-----------------------------------------------------------------------------
  258. // Name: CreateMeshFromHeightMap
  259. // Desc: 
  260. //-----------------------------------------------------------------------------
  261. HRESULT CTerrainMesh::CreateMeshFromHeightMap( int nWidth, int nHeight )
  262. {
  263.     HRESULT hr;
  264.     
  265.     int nNumStrips      = (nWidth-1);
  266.     int nQuadsPerStrip  = (nHeight-1);
  267.     m_dwNumFaces    = nNumStrips * nQuadsPerStrip * 2;
  268.     m_dwNumVerties  = nWidth * nHeight;
  270.     hr = D3DXCreateMeshFVF( m_dwNumFaces, m_dwNumVerties, D3DXMESH_MANAGED, TERRIAN_FVF, g_pd3dDevice, &m_pMesh );
  271.     if( FAILED(hr) )
  272.         return DXTRACE_ERR( TEXT("D3DXCreateMeshFVF"), hr );
  274.     WORD* pIndexBuffer = NULL;
  275.     hr = m_pMesh->LockIndexBuffer( 0, (void**) &pIndexBuffer );
  276.     if( FAILED(hr) )
  277.         return DXTRACE_ERR( TEXT("LockIndexBuffer"), hr );
  279.     int iStrip, iQuad;
  280.     int iRow, iCol;
  281.     float iX, iZ;
  283.     for( iStrip = 0; iStrip<nNumStrips; iStrip++ )
  284.     {
  285.         WORD nCurRow1 = (iStrip+0)*nHeight;
  286.         WORD nCurRow2 = (iStrip+1)*nHeight;
  288.         for( iQuad = 0; iQuad<nQuadsPerStrip; iQuad++ )
  289.         {
  290.             // first tri 
  291.             *pIndexBuffer++ = nCurRow1;
  292.             *pIndexBuffer++ = nCurRow1 + 1;
  293.             *pIndexBuffer++ = nCurRow2;
  295.             // second tri 
  296.             *pIndexBuffer++ = nCurRow1 + 1;
  297.             *pIndexBuffer++ = nCurRow2 + 1;
  298.             *pIndexBuffer++ = nCurRow2;
  300.             nCurRow1++;
  301.             nCurRow2++;
  302.         }
  303.     }
  305.     hr = m_pMesh->UnlockIndexBuffer();
  306.     if( FAILED(hr) )
  307.         return DXTRACE_ERR( TEXT("UnlockIndexBuffer"), hr );
  309.     TERRIANVERTEX* pVertexBuffer = NULL;
  310.     hr = m_pMesh->LockVertexBuffer( 0, (void**) &pVertexBuffer );
  311.     if( FAILED(hr) )
  312.         return DXTRACE_ERR( TEXT("LockVertexBuffer"), hr );
  314.     float fSizeQuadX = 1.0f;
  315.     float fSizeQuadZ = 1.0f;
  317.     D3DSURFACE_DESC surfDesc;
  318.     FLOAT fTexelSizeU;
  319.     FLOAT fTexelSizeV;
  321.     if( m_pTexture )
  322.     {
  323.         hr = m_pTexture->GetLevelDesc( 0, &surfDesc );
  324.         fTexelSizeU = 1.0f/surfDesc.Width;
  325.         fTexelSizeV = 1.0f/surfDesc.Height;
  326.     }
  327.     else
  328.     {
  329.         fTexelSizeU = 1.0f/256.0f;
  330.         fTexelSizeV = 1.0f/256.0f;
  331.     }
  333.     iX = m_fWorldOffsetX;
  334.     for( iCol = 0; iCol<nWidth; iCol++ )
  335.     {
  336.         iZ = m_fWorldOffsetZ;
  337.         
  338.         for( iRow = 0; iRow<nHeight; iRow++ )
  339.         {
  340.             // Add a nudge factor if we're along the edges to 
  341.             // cover any minuate cracks in between the meshs
  342.             FLOAT fNudgeX = 0.0f;
  343.             FLOAT fNudgeZ = 0.0f;
  344.             if( iRow==0 )
  345.                 fNudgeZ = -0.01f;
  346.             if( iRow==nHeight-1 )
  347.                 fNudgeZ = 0.01f;
  348.             if( iCol==0 )
  349.                 fNudgeX = -0.01f;
  350.             if( iCol==nWidth-1 )
  351.                 fNudgeX = 0.01f;
  353.             // Ask the terrain engine what the height is at this point
  354.             pVertexBuffer->p = D3DXVECTOR3( fNudgeX+iX-m_fWorldOffsetX, 
  355.                                             g_pTerrainEngine->GetHeight( iX, iZ ), 
  356.                                             fNudgeZ+iZ-m_fWorldOffsetZ );
  358.             // Compute the normal by hand
  359.             D3DXVECTOR3 vecN;
  360.             D3DXVECTOR3 vPt = D3DXVECTOR3( iX, g_pTerrain->GetHeight( iX, iZ ), iZ );
  361.             D3DXVECTOR3 vN = D3DXVECTOR3( iX, g_pTerrain->GetHeight( iX+0.0f, iZ+1.0f ), iZ+1.0f );
  362.             D3DXVECTOR3 vE = D3DXVECTOR3( iX+1.0f, g_pTerrain->GetHeight( iX+1.0f, iZ+0.0f ), iZ );
  363.             D3DXVECTOR3 v1 = vN - vPt;
  364.             D3DXVECTOR3 v2 = vE - vPt;
  365.             D3DXVec3Cross( &vecN, &v1, &v2 );
  366.             D3DXVec3Normalize(&vecN, &vecN);
  368.             pVertexBuffer->n = vecN;
  370.             // Set the texture coords from (0.0f + 0.5*texel) to (1.0f - 0.5*texel) 
  371.             // to get perfect texel mapping on the mesh
  372.             pVertexBuffer->tu = ( (float) iCol / (float) (nWidth-1)  ) * (1.0f-fTexelSizeU) + 0.5f*fTexelSizeU;
  373.             pVertexBuffer->tv = ( (float) iRow / (float) (nHeight-1) ) * (1.0f-fTexelSizeV) + 0.5f*fTexelSizeV;
  375.             pVertexBuffer++;
  376.             iZ += fSizeQuadZ;
  377.         }
  379.         iX += fSizeQuadX;
  380.     }
  382.     hr = m_pMesh->UnlockVertexBuffer();
  383.     if( FAILED(hr) )
  384.         return DXTRACE_ERR( TEXT("UnlockVertexBuffer"), hr );
  386.     BOOL bGenAdj        = g_Profile.bOptimizeMesh || g_Profile.bCompactMesh || g_Profile.bSimplifyMesh;
  387.     BOOL bOptimize      = g_Profile.bOptimizeMesh && bGenAdj;
  388.     BOOL bCompact       = g_Profile.bCompactMesh && bOptimize;
  389.     BOOL bSimplifyMesh  = g_Profile.bSimplifyMesh && bGenAdj;
  390.     DWORD* pdwAdjaceny  = NULL;
  391.     if( bGenAdj ) 
  392.     {
  393.         pdwAdjaceny = new DWORD[ 3 * m_pMesh->GetNumFaces() ];
  394.         if( pdwAdjaceny == NULL )
  395.             return E_OUTOFMEMORY;
  397.         hr = m_pMesh->GenerateAdjacency( 0.01f, pdwAdjaceny );
  398.         if( FAILED(hr) )
  399.             return DXTRACE_ERR( TEXT("GenerateAdjacency"), hr );
  400.     }
  402.     if( bOptimize )
  403.     {
  404.         DWORD* pdwAdjacenyOut = NULL;
  405.         if( bGenAdj )
  406.         {
  407.             pdwAdjacenyOut = new DWORD[ 3 * m_pMesh->GetNumFaces() ];
  408.             if( pdwAdjacenyOut == NULL )
  409.                 return E_OUTOFMEMORY;
  410.         }
  412.         DWORD dwFlags = D3DXMESHOPT_VERTEXCACHE;
  413.         if( bCompact )
  414.             dwFlags |= D3DXMESHOPT_COMPACT;
  415.         hr = m_pMesh->OptimizeInplace( dwFlags, pdwAdjaceny, pdwAdjacenyOut, NULL, NULL );
  416.         if( FAILED(hr) )
  417.             return DXTRACE_ERR( TEXT("D3DXSimplifyMesh"), hr );
  419.         if( bGenAdj )
  420.         {
  421.             SAFE_DELETE_ARRAY( pdwAdjaceny );
  422.             pdwAdjaceny = pdwAdjacenyOut;
  423.         }
  424.     }
  426.     if( bGenAdj ) 
  427.     {
  428.         if( bSimplifyMesh )
  429.         {
  430.             ID3DXMesh* pMesh;
  431.             D3DXATTRIBUTEWEIGHTS d3daw;
  432.             ZeroMemory( &d3daw, sizeof(D3DXATTRIBUTEWEIGHTS) );
  433.             d3daw.Position = 1.0f;
  434.             d3daw.Boundary = 10000.0f;
  435.             d3daw.Normal   = 1.0f;
  437.             hr = D3DXSimplifyMesh( m_pMesh, pdwAdjaceny, &d3daw, NULL, (DWORD)(m_dwNumFaces*g_Profile.fSimplifyMeshFactor), D3DXMESHSIMP_FACE, &pMesh );
  438.             if( FAILED(hr) )
  439.                 return DXTRACE_ERR( TEXT("D3DXSimplifyMesh"), hr );
  440.             SAFE_RELEASE( m_pMesh );
  441.             m_pMesh = pMesh;
  442.         }
  444.         SAFE_DELETE_ARRAY( pdwAdjaceny );
  445.     }
  447.     assert( m_pMesh != NULL );
  449.     return S_OK;
  450. }
  455. //-----------------------------------------------------------------------------
  456. // Name: 
  457. // Desc: 
  458. //-----------------------------------------------------------------------------
  459. HRESULT CTerrainMesh::CorrectTextureEdge()
  460. {
  461.     HRESULT hr;
  463.     if( NULL == m_pTexture )
  464.         return S_OK;
  466.     DWORD dwLevelCount = m_pTexture->GetLevelCount();
  467.     
  468.     for( DWORD iLevel=0; iLevel<dwLevelCount; iLevel++ )
  469.     {
  470.         D3DSURFACE_DESC surfDesc;
  471.         hr = m_pTexture->GetLevelDesc( iLevel, &surfDesc );
  472.     
  473.         D3DLOCKED_RECT LockedRect;
  474.         hr = m_pTexture->LockRect( iLevel, &LockedRect, NULL, 0 );
  475.         if( FAILED(hr) )
  476.             return S_OK; // can't lock texture if its a rendertarget
  477. //            return DXTRACE_ERR( TEXT("LockRect"), hr );
  479.         switch( surfDesc.Format )
  480.         {
  481.             case D3DFMT_A8R8G8B8:
  482.             case D3DFMT_X8R8G8B8:
  483.             {
  484.                 DWORD* pBits;
  485.                 for( DWORD iTexelZ=0; iTexelZ<surfDesc.Height; iTexelZ++ )
  486.                 {
  487.                     FLOAT fMapZ = (float) iTexelZ / ( (float)surfDesc.Height / (float)m_pMap->m_nZSize );
  489.                     pBits = (DWORD*) ((BYTE*)LockedRect.pBits + LockedRect.Pitch*iTexelZ);
  490.                     pBits += (surfDesc.Width-1);
  491.                     *pBits = g_pTerrainEngine->GetTexelColor( iLevel, 
  492.                                                               m_fWorldOffsetX + m_pMap->m_fXSize,
  493.                                                               m_fWorldOffsetZ + fMapZ );
  494.                 }        
  496.                 pBits = (DWORD*) ((BYTE*)LockedRect.pBits + LockedRect.Pitch*(surfDesc.Height-1));
  497.                 for( DWORD iTexelX=0; iTexelX<surfDesc.Width; iTexelX++ )
  498.                 {
  499.                     FLOAT fMapX = (float) iTexelX / ( (float)surfDesc.Width / (float)m_pMap->m_nXSize );
  501.                     *pBits = g_pTerrainEngine->GetTexelColor( iLevel, 
  502.                                                               m_fWorldOffsetX + fMapX, 
  503.                                                               m_fWorldOffsetZ + m_pMap->m_fZSize );
  505.                     pBits++;
  506.                 }        
  508.                 break;
  509.             }
  510.         }
  512.         hr = m_pTexture->UnlockRect( iLevel );
  513.         if( FAILED(hr) )
  514.             return DXTRACE_ERR( TEXT("UnlockRect"), hr );   
  515.     }
  517.     return S_OK;
  518. }
  523. //-----------------------------------------------------------------------------
  524. // Name: 
  525. // Desc: 
  526. //-----------------------------------------------------------------------------
  527. HRESULT CTerrainMesh::GenerateMipMaps()
  528. {
  529.     if( g_Profile.bGenerateMipMaps )
  530.     {
  531.         HRESULT hr;
  532.         LPDIRECT3DTEXTURE9 pTexture = NULL;
  534.         hr = D3DXCreateTexture( g_pd3dDevice, m_pLandStyle->dwTextureSize, m_pLandStyle->dwTextureSize, D3DX_DEFAULT, 0, 
  535.                                 m_fmtTexture, D3DPOOL_MANAGED, &pTexture );
  536.         if( FAILED(hr) )
  537.             return DXTRACE_ERR( TEXT("D3DXCreateTexture"), hr );
  540.         IDirect3DSurface9* pSurfaceSrc = NULL;
  541.         IDirect3DSurface9* pSurfaceDest = NULL;
  542.         pTexture->GetSurfaceLevel( 0, &pSurfaceDest );
  543.         m_pTexture->GetSurfaceLevel( 0, &pSurfaceSrc );
  545.         hr = D3DXLoadSurfaceFromSurface( pSurfaceDest, NULL, NULL, 
  546.                                          pSurfaceSrc, NULL, NULL, 
  547.                                          D3DX_FILTER_POINT, 0 );
  548.         if( FAILED(hr) )
  549.             return DXTRACE_ERR( TEXT("D3DXLoadSurfaceFromSurface"), hr );
  551.         SAFE_RELEASE( pSurfaceDest );
  552.         SAFE_RELEASE( pSurfaceSrc );
  554.         SAFE_RELEASE( m_pTexture );
  555.         m_pTexture = pTexture;
  556.         pTexture = NULL;
  558.         hr = D3DXFilterTexture( m_pTexture, NULL, 0, D3DX_FILTER_BOX );
  559.     }
  561.     return S_OK;
  562. }
  566. //-----------------------------------------------------------------------------
  567. // Name: 
  568. // Desc: 
  569. //-----------------------------------------------------------------------------
  570. HRESULT CTerrainMesh::CreateTestTexture( int nWidth, int nHeight )
  571. {
  572.     HRESULT hr;
  573.     
  574.     hr = D3DXCreateTexture( g_pd3dDevice, nWidth, nHeight, 1, 0, 
  575.                             D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &m_pTexture );
  576.     if( FAILED(hr) )
  577.         return DXTRACE_ERR( TEXT("D3DXCreateTexture"), hr );
  578.     
  579.     D3DSURFACE_DESC surfDesc;
  580.     hr = m_pTexture->GetLevelDesc( 0, &surfDesc );
  581.     
  582.     D3DLOCKED_RECT LockedRect;
  583.     hr = m_pTexture->LockRect( 0, &LockedRect, NULL, 0 );
  584.     if( FAILED(hr) )
  585.         return DXTRACE_ERR( TEXT("LockRect"), hr );
  587.     DWORD* pBits;
  588.     for( DWORD iTexelZ=0; iTexelZ<surfDesc.Height; iTexelZ++ )
  589.     {
  590.         pBits = (DWORD*) ((BYTE*)LockedRect.pBits + LockedRect.Pitch*iTexelZ);
  592.         for( DWORD iTexelX=0; iTexelX<surfDesc.Width; iTexelX++ )
  593.         {
  594.             *pBits = 0xFF00FF00;
  595.             pBits++;
  596.         }
  597.     }        
  599.     hr = m_pTexture->UnlockRect( 0 );
  600.     if( FAILED(hr) )
  601.         return DXTRACE_ERR( TEXT("UnlockRect"), hr );   
  603.     return S_OK;
  604. }
  609. //-----------------------------------------------------------------------------
  610. // Name: 
  611. // Desc: 
  612. //-----------------------------------------------------------------------------
  613. HRESULT CTerrainMesh::ReadTextureFromFile( int nWidth, int nHeight )
  614. {
  615.     HRESULT hr;
  617.     D3DXIMAGE_INFO d3dxImageInfo;
  618.     D3DXGetImageInfoFromFile( m_pLandStyle->szTextureMap, &d3dxImageInfo );
  620.     // Create a texture w/ a format supported by the video card
  621.     TCHAR strFile[MAX_PATH];
  622.     CMyApplication::FindMediaFileCch( strFile, MAX_PATH, m_pLandStyle->szTextureMap );
  623.     hr = D3DXCreateTextureFromFileEx( g_pd3dDevice, strFile,
  624.                                       m_pLandStyle->dwTextureSize, m_pLandStyle->dwTextureSize, 1, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_FILTER_LINEAR,
  625.                                       D3DX_FILTER_LINEAR, 0, NULL, NULL, &m_pTexture );
  626.     if( FAILED(hr) )
  627.     {
  628.         g_pApp->CleanupAndDisplayError( DONUTSERR_ARTLOADFAILED, m_pLandStyle->szTextureMap, strFile );
  629.         return DXTRACE_ERR( TEXT("D3DXCreateTexture"), hr );
  630.     }
  632.     return S_OK;
  633. }
  638. //-----------------------------------------------------------------------------
  639. // Name: CreateTextureFromLayers()
  640. // Desc: This function takes a list of texture files and tiles them.  It does a 
  641. //       multipass alpha blend into a final m_pTexture.  The alpha layers are 
  642. //       created for each texture based on the height of the mesh.
  643. //-----------------------------------------------------------------------------
  644. HRESULT CTerrainMesh::CreateTextureFromLayers( int nWidth, int nHeight )
  645. {
  646.     HRESULT hr;
  647.     D3DSURFACE_DESC surfDesc;
  648.     D3DVIEWPORT9 vp;
  649.     DWORD iTexture;
  650.    
  651.     LPDIRECT3DTEXTURE9 pSrcTex[MAX_SOURCE_TEXTURES];           
  652.     ZeroMemory( pSrcTex, sizeof(LPDIRECT3DTEXTURE9)*MAX_SOURCE_TEXTURES );
  654.     LPDIRECT3DTEXTURE9 pAlphaTex[MAX_SOURCE_TEXTURES];           
  655.     ZeroMemory( pAlphaTex, sizeof(LPDIRECT3DTEXTURE9)*MAX_SOURCE_TEXTURES );
  657.     DWORD i;
  659.     // For each src texture, read the texture from a file and create an alpha mask for it
  660.     for( i=0; i<m_pLandStyle->dwNumLayers; i++ )
  661.     {
  662.         // Read source texture from file.  
  663.         TCHAR strFile[MAX_PATH];
  664.         CMyApplication::FindMediaFileCch( strFile, MAX_PATH, m_pLandStyle->aLayerTexture[i] );
  665.         hr = D3DXCreateTextureFromFileEx( g_pd3dDevice, strFile,
  666.                                           D3DX_DEFAULT, D3DX_DEFAULT, 1, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, 
  667.                                           D3DX_FILTER_LINEAR, D3DX_FILTER_LINEAR, 0, NULL, NULL, &pSrcTex[i] );
  668.         if( FAILED(hr) )
  669.         {
  670.             g_pApp->CleanupAndDisplayError( DONUTSERR_ARTLOADFAILED, m_pLandStyle->aLayerTexture[i], strFile );
  671.             return DXTRACE_ERR( TEXT("D3DXCreateTextureFromFileEx"), hr );
  672.         }
  674.         // Create alpha mask for each source texture.  
  675.         hr = D3DXCreateTexture( g_pd3dDevice, nWidth, nHeight, 
  676.                                 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, 
  677.                                 &pAlphaTex[i] );
  678.         if( FAILED(hr) )
  679.             return DXTRACE_ERR( TEXT("D3DXCreateTexture"), hr );
  680.     }
  682.     // Get the backbuffer format
  683.     LPDIRECT3DSURFACE9 pBackBuffer = NULL;
  684.     D3DSURFACE_DESC    d3dsdBackBuffer;   // Surface desc of the backbuffer
  685.     g_pd3dDevice->GetBackBuffer( 0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer );
  686.     pBackBuffer->GetDesc( &d3dsdBackBuffer );
  687.     SAFE_RELEASE( pBackBuffer );
  689.     // Create a render target texture if possible
  690.     hr = D3DXCreateTexture( g_pd3dDevice, m_pLandStyle->dwTextureSize, m_pLandStyle->dwTextureSize, 
  691.                             1, D3DUSAGE_RENDERTARGET, 
  692.                             D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_pTexture );
  693.     if( FAILED(hr) )
  694.     {
  695.         // Fallback to a normal texture with the same format as the backbuffer
  696.         // normally a RENDERTARGET surface can be created using the backbuffer format
  697.         hr = D3DXCreateTexture( g_pd3dDevice, m_pLandStyle->dwTextureSize, m_pLandStyle->dwTextureSize, 1, 0, 
  698.                                 D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &m_pTexture );
  699.         if( FAILED(hr) )
  700.             return DXTRACE_ERR( TEXT("D3DXCreateTexture"), hr );
  701.     }
  703.     // Create a ID3DXRenderToSurface using the same height/width/format as the
  704.     // texture that we're are going to use with this ID3DXRenderToSurface
  705.     hr = m_pTexture->GetLevelDesc( 0, &surfDesc );
  706.     ID3DXRenderToSurface* pRenderToSurface = NULL;
  707.     hr = D3DXCreateRenderToSurface( g_pd3dDevice, surfDesc.Width, surfDesc.Height, surfDesc.Format, 
  708.                                     FALSE, D3DFMT_UNKNOWN, &pRenderToSurface );
  709.     if( FAILED(hr) )
  710.         return DXTRACE_ERR( TEXT("D3DXCreateRenderToSurface"), hr );
  712.     // Compute the alpha mask for each layer
  713.     for( iTexture=0; iTexture<m_pLandStyle->dwNumLayers; iTexture++ )
  714.     {
  715.         hr = pAlphaTex[iTexture]->GetLevelDesc( 0, &surfDesc );
  716.         if( FAILED(hr) )
  717.             return DXTRACE_ERR( TEXT("GetLevelDesc"), hr );
  718.         assert( surfDesc.Format == D3DFMT_A8R8G8B8 );
  720.         D3DLOCKED_RECT LockedRect;
  721.         hr = pAlphaTex[iTexture]->LockRect( 0, &LockedRect, NULL, 0 );
  722.         if( FAILED(hr) )
  723.             return DXTRACE_ERR( TEXT("LockRect"), hr );
  725.         DWORD* pBits;
  726.         for( DWORD iTexelZ=0; iTexelZ<surfDesc.Height; iTexelZ++ )
  727.         {
  728.             pBits = (DWORD*) ((BYTE*)LockedRect.pBits + LockedRect.Pitch*iTexelZ);
  730.             for( DWORD iTexelX=0; iTexelX<surfDesc.Width; iTexelX++ )
  731.             {
  732.                 FLOAT fHeight;
  733.                 BYTE  nAlpha;
  735.                 // The final mesh texture 
  736.                 float iMapX = ( (float) iTexelX / (float) surfDesc.Width )  * m_pMap->m_fXSize;
  737.                 float iMapZ = ( (float) iTexelZ / (float) surfDesc.Height ) * m_pMap->m_fZSize;
  739.                 // Get the height of the mesh at this point
  740.                 fHeight = g_pTerrainEngine->GetHeight( iMapX + m_fWorldOffsetX, iMapZ + m_fWorldOffsetZ );
  741.                 fHeight /= MAX_HEIGHT_OF_MAP;
  742.  
  743.                 // The TextureAlpha() function will return the alpha for this
  744.                 // mask.  It also assures that the sum of the alpha mask at each point
  745.                 // adds up to 0xFF.
  746.                 nAlpha = TextureAlpha( fHeight, iTexture );  
  748.                 *pBits = (nAlpha << 24);
  749.                 pBits++;
  750.             }
  751.         }        
  752.         hr = pAlphaTex[iTexture]->UnlockRect( 0 );
  753.         if( FAILED(hr) )
  754.             return DXTRACE_ERR( TEXT("UnlockRect"), hr );   
  755.     } 
  757.     // Create a RHW quad to render all the layers into.  The render target
  758.     // will be the final texture, m_pTexture.
  759.     int nMeshWidth      = 16;
  760.     int nMeshHeight     = 16;
  761.     int nNumStrips      = (nMeshWidth-1);
  762.     int nQuadsPerStrip  = (nMeshHeight-1);
  763.     DWORD dwNumFaces    = nNumStrips * nQuadsPerStrip * 2;
  764.     DWORD dwNumVerties  = nMeshWidth * nMeshHeight;
  765.     LPDIRECT3DINDEXBUFFER9  pIB = NULL;
  766.     LPDIRECT3DVERTEXBUFFER9 pVB = NULL;
  768.     hr = g_pd3dDevice->CreateIndexBuffer( dwNumFaces * 3 * sizeof(WORD),
  769.                                          D3DUSAGE_WRITEONLY,
  770.                                          D3DFMT_INDEX16, D3DPOOL_MANAGED,
  771.                                          &pIB, NULL );
  772.     if( FAILED(hr) )
  773.         return DXTRACE_ERR( TEXT("CreateIndexBuffer"), hr );
  775.     hr = g_pd3dDevice->CreateVertexBuffer( dwNumVerties * sizeof(RHW_VERTEX),
  776.                                          D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY,
  777.                                          RHW_FVF, D3DPOOL_DEFAULT ,
  778.                                          &pVB, NULL );
  779.     if( FAILED(hr) )
  780.         return DXTRACE_ERR( TEXT("CreateVertexBuffer"), hr );
  782.     WORD* pIndexBuffer = NULL;
  783.     hr = pIB->Lock( 0, 0, (void**) &pIndexBuffer, 0 );
  784.     if( FAILED(hr) )
  785.         return DXTRACE_ERR( TEXT("LockIndexBuffer"), hr );
  787.     int iStrip, iQuad;
  788.     int iRow, iCol;
  789.     float iX, iY;
  791.     for( iStrip = 0; iStrip<nNumStrips; iStrip++ )
  792.     {
  793.         WORD nCurRow1 = (iStrip+0)*nMeshHeight;
  794.         WORD nCurRow2 = (iStrip+1)*nMeshHeight;
  796.         for( iQuad = 0; iQuad<nQuadsPerStrip; iQuad++ )
  797.         {
  798.             // first tri 
  799.             *pIndexBuffer++ = nCurRow1;
  800.             *pIndexBuffer++ = nCurRow1 + 1;
  801.             *pIndexBuffer++ = nCurRow2;
  803.             // second tri 
  804.             *pIndexBuffer++ = nCurRow1 + 1;
  805.             *pIndexBuffer++ = nCurRow2 + 1;
  806.             *pIndexBuffer++ = nCurRow2;
  808.             nCurRow1++;
  809.             nCurRow2++;
  810.         }
  811.     }
  813.     hr = pIB->Unlock();
  814.     if( FAILED(hr) )
  815.         return DXTRACE_ERR( TEXT("UnlockIndexBuffer"), hr );
  817.     // Setup the viewport for the ID3DXRenderToSurface.  Make the viewport the
  818.     // same size as the surface that will be the target.
  819.     hr = m_pTexture->GetLevelDesc( 0, &surfDesc );
  820.     vp.Width  = surfDesc.Width;
  821.     vp.Height = surfDesc.Height;
  822.     vp.MinZ   = 0;
  823.     vp.MaxZ   = 1.0f;
  824.     vp.X      = 0;
  825.     vp.Y      = 0;
  827.     // Render to the surface of m_pTexture.  Use the ID3DXRenderToSurface 
  828.     // to render surface, even if the surface isn't a render target.  Some
  829.     // video cards don't support textures as render targets.
  830.     IDirect3DSurface9* pRenderSurface = NULL;
  831.     m_pTexture->GetSurfaceLevel( 0, &pRenderSurface );
  832.     pRenderToSurface->BeginScene( pRenderSurface, &vp );
  834.     g_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET, 0xFF000000, 1.0f, 0L );
  836.     D3DMATERIAL9 mtrl;
  837.     ZeroMemory( &mtrl, sizeof(D3DMATERIAL9) );
  838.     mtrl.Diffuse.r = mtrl.Ambient.r = 1.0f;
  839.     mtrl.Diffuse.g = mtrl.Ambient.g = 1.0f;
  840.     mtrl.Diffuse.b = mtrl.Ambient.b = 1.0f;
  841.     mtrl.Diffuse.a = mtrl.Ambient.a = 1.0f;
  842.     hr = g_pd3dDevice->SetMaterial( &mtrl );
  844.     g_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
  845.     g_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
  847.     hr = g_pd3dDevice->SetFVF( RHW_FVF );
  848.     hr = g_pd3dDevice->SetStreamSource( 0, pVB, 0, sizeof(RHW_VERTEX) );
  849.     hr = g_pd3dDevice->SetIndices( pIB );
  851.     g_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
  852.     g_pd3dDevice->SetRenderState( D3DRS_SRCBLEND,     D3DBLEND_SRCALPHA  );
  853.     g_pd3dDevice->SetRenderState( D3DRS_DESTBLEND,    D3DBLEND_ONE );
  854.     g_pd3dDevice->SetRenderState( D3DRS_TEXTUREFACTOR, 0 );
  856.     g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1  );
  857.     g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
  858.     g_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_SELECTARG1  );
  859.     g_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
  861.     g_pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_BLENDCURRENTALPHA );
  862.     g_pd3dDevice->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
  863.     g_pd3dDevice->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_TFACTOR );
  864.     g_pd3dDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP,   D3DTOP_SELECTARG1  );
  865.     g_pd3dDevice->SetTextureStageState( 1, D3DTSS_ALPHAARG1, D3DTA_CURRENT );
  867.     g_pd3dDevice->SetTextureStageState( 2, D3DTSS_COLOROP,   D3DTOP_DISABLE );
  869.     for( i=0; i<m_pLandStyle->dwNumLayers; i++ )
  870.     {
  871.         RHW_VERTEX* pVertexBuffer = NULL;
  872.         hr = pVB->Lock( 0, 0, (void**) &pVertexBuffer, D3DLOCK_DISCARD );
  873.         if( FAILED(hr) )
  874.             return DXTRACE_ERR( TEXT("LockVertexBuffer"), hr );
  876.         float fSizeQuadX = 1.0f;
  877.         float fSizeQuadY = 1.0f;
  878.         hr = m_pTexture->GetLevelDesc( 0, &surfDesc );
  880.         iX = 0.0f;
  881.         for( iCol = 0; iCol<nMeshWidth; iCol++ )
  882.         {
  883.             iY = 0.0f;
  884.             
  885.             for( iRow = 0; iRow<nMeshHeight; iRow++ )
  886.             {
  887.                 // The first texture is the alpha mask.  
  888.                 float tu1 = (float) iRow / (float) (nMeshWidth-1);
  889.                 float tv1 = (float) iCol / (float) (nMeshHeight-1);
  891.                 // The second texture is the source texture, and it's tiled.
  892.                 // Also add a small amount of random variation to the tiling.
  893.                 float tu2 = (float) iRow / (float)  (nMeshWidth-1) * m_pLandStyle->aLayerTile[i] + ((float)(rand() % 100)/100.0f-0.50f)*m_pLandStyle->aLayerRandomness[i];
  894.                 float tv2 = (float) iCol / (float) (nMeshHeight-1) * m_pLandStyle->aLayerTile[i] + ((float)(rand() % 100)/100.0f-0.50f)*m_pLandStyle->aLayerRandomness[i];
  896.                 pVertexBuffer->p   = D3DXVECTOR4( tu1*surfDesc.Width, tv1*surfDesc.Height, 0.0f, 1.0f );
  897.                 pVertexBuffer->tu1 = tu1;
  898.                 pVertexBuffer->tv1 = tv1;
  900.                 pVertexBuffer->tu2 = tu2;
  901.                 pVertexBuffer->tv2 = tv2;
  903.                 pVertexBuffer++;
  905.                 iY += fSizeQuadY;
  906.             }
  908.             iX += fSizeQuadX;
  909.         }
  911.         hr = pVB->Unlock(); 
  912.         if( FAILED(hr) )
  913.             return DXTRACE_ERR( TEXT("UnlockVertexBuffer"), hr );
  915.         g_pd3dDevice->SetStreamSource( 0, pVB, 0, sizeof(RHW_VERTEX) );
  917.         g_pd3dDevice->SetTexture( 0, pAlphaTex[i] );
  918.         g_pd3dDevice->SetTexture( 1, pSrcTex[i] );
  920.         g_pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, dwNumVerties, 0, dwNumFaces );
  921.     }
  923.     hr = pRenderToSurface->EndScene( D3DX_FILTER_LINEAR );
  924.     SAFE_RELEASE( pRenderSurface );
  926.     g_pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_DISABLE );
  928.     SAFE_RELEASE( pIB );
  929.     SAFE_RELEASE( pVB );
  931.     SAFE_RELEASE( pRenderToSurface );
  933.     for( i=0; i<m_pLandStyle->dwNumLayers; i++ )
  934.     {
  935.         SAFE_RELEASE( pSrcTex[i] );
  936.         SAFE_RELEASE( pAlphaTex[i] );
  937.     }
  938.     
  939.     return S_OK;
  940. }
  945. //-----------------------------------------------------------------------------
  946. // Name: 
  947. // Desc: 
  948. //-----------------------------------------------------------------------------
  949. HRESULT CTerrainMesh::CreateTextureFromHeight( int nWidth, int nHeight )
  950. {
  951.     HRESULT hr;
  953.     // Create a D3DFMT_A8R8G8B8 texture.  use D3DPOOL_SCRATCH to create this texture 
  954.     // even if the video card doesn't support it.
  955.     LPDIRECT3DTEXTURE9 pScratchTexture = NULL;
  956.     hr = D3DXCreateTexture( g_pd3dDevice, nWidth*2, nHeight*2, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &pScratchTexture );
  957.     if( FAILED(hr) )
  958.         return DXTRACE_ERR( TEXT("D3DXCreateTexture"), hr );
  960.     D3DSURFACE_DESC surfDesc;
  961.     hr = pScratchTexture->GetLevelDesc( 0, &surfDesc );
  962.     if( FAILED(hr) )
  963.         return DXTRACE_ERR( TEXT("GetLevelDesc"), hr );
  964.     assert( surfDesc.Format == D3DFMT_A8R8G8B8 );
  966.     D3DLOCKED_RECT LockedRect;
  967.     hr = pScratchTexture->LockRect( 0, &LockedRect, NULL, 0 );
  968.     if( FAILED(hr) )
  969.         return DXTRACE_ERR( TEXT("LockRect"), hr );
  971.     DWORD* pBits;
  972.     for( DWORD iTexelZ=0; iTexelZ<surfDesc.Height; iTexelZ++ )
  973.     {
  974.         pBits = (DWORD*) ((BYTE*)LockedRect.pBits + LockedRect.Pitch*iTexelZ);
  976.         for( DWORD iTexelX=0; iTexelX<surfDesc.Width; iTexelX++ )
  977.         {
  978.             FLOAT fHeight;
  980.             fHeight = g_pTerrainEngine->GetHeight( iTexelX/2.0f + m_fWorldOffsetX, iTexelZ/2.0f + m_fWorldOffsetZ );
  981.             fHeight /= MAX_HEIGHT_OF_MAP;
  983.             float aClrFactor[10];
  984.             DWORD iColor;
  985.             for( iColor=0; iColor<m_pLandStyle->dwNumLayers; iColor++ )
  986.             {
  987.                 float fHigh, fLow;
  989.                 if( iColor==0 )
  990.                     fLow = -0.25f;
  991.                 else
  992.                     fLow = m_pLandStyle->aLayerHeight[iColor-1];
  994.                 if( iColor==m_pLandStyle->dwNumLayers-1 )
  995.                     fHigh = 1.25f;
  996.                 else
  997.                     fHigh = m_pLandStyle->aLayerHeight[iColor+1];
  999.                 aClrFactor[iColor] = TextureColorFactor( iColor, fHeight );  
  1000.             }
  1002.             FLOAT fRed   = 0.0f;
  1003.             FLOAT fGreen = 0.0f;
  1004.             FLOAT fBlue  = 0.0f;
  1006.             for( iColor=0; iColor<m_pLandStyle->dwNumLayers; iColor++ )
  1007.             {
  1008.                 fRed   += aClrFactor[iColor]*(float)RVALUE(m_pLandStyle->aLayerColor[iColor]);
  1009.                 fGreen += aClrFactor[iColor]*(float)GVALUE(m_pLandStyle->aLayerColor[iColor]);
  1010.                 fBlue  += aClrFactor[iColor]*(float)BVALUE(m_pLandStyle->aLayerColor[iColor]);
  1011.             }
  1013.             DWORD nRed   = (DWORD) fRed;
  1014.             DWORD nGreen = (DWORD) fGreen;
  1015.             DWORD nBlue  = (DWORD) fBlue;
  1017.             if( nRed > 0xFF )
  1018.                 nRed = 0xFF;
  1019.             if( nGreen > 0xFF )
  1020.                 nGreen = 0xFF;
  1021.             if( nBlue > 0xFF )
  1022.                 nBlue = 0xFF;
  1024.             *pBits = (0xFF << 24) + (nRed << 16) + (nGreen << 8) + (nBlue << 0);
  1025.             pBits++;
  1026.         }
  1027.     }        
  1029.     hr = pScratchTexture->UnlockRect( 0 );
  1030.     if( FAILED(hr) )
  1031.         return DXTRACE_ERR( TEXT("UnlockRect"), hr );   
  1033.     // Create a texture w/ a format supported by the video card
  1034.     hr = D3DXCreateTexture( g_pd3dDevice, nWidth*2, nHeight*2, 1, 0, m_fmtTexture, D3DPOOL_MANAGED, &m_pTexture );
  1035.     if( FAILED(hr) )
  1036.         return DXTRACE_ERR( TEXT("D3DXCreateTexture"), hr );
  1038.     // Use d3dx to convert from the scratch texture to a card supported texture format 
  1039.     IDirect3DSurface9* pSurfaceSrc = NULL;
  1040.     IDirect3DSurface9* pSurfaceDest = NULL;
  1041.     m_pTexture->GetSurfaceLevel( 0, &pSurfaceDest );
  1042.     pScratchTexture->GetSurfaceLevel( 0, &pSurfaceSrc );
  1044.     hr = D3DXLoadSurfaceFromSurface( pSurfaceDest, NULL, NULL, pSurfaceSrc, NULL, NULL, D3DX_FILTER_POINT, 0 );
  1045.     if( FAILED(hr) )
  1046.         return DXTRACE_ERR( TEXT("D3DXLoadSurfaceFromSurface"), hr );
  1048.     SAFE_RELEASE( pSurfaceDest );
  1049.     SAFE_RELEASE( pSurfaceSrc );
  1051.     SAFE_RELEASE( pScratchTexture );
  1052.     
  1053.     return S_OK;
  1054. }
  1059. //-----------------------------------------------------------------------------
  1060. // Name: 
  1061. // Desc: 
  1062. //-----------------------------------------------------------------------------
  1063. HRESULT CTerrainMesh::FrameMove( const float fElapsedTime )
  1064. {
  1065.     return S_OK;
  1066. }
  1071. //-----------------------------------------------------------------------------
  1072. // Name: 
  1073. // Desc: 
  1074. //-----------------------------------------------------------------------------
  1075. HRESULT CTerrainMesh::RenderFrame( float fWrapOffsetX, float fWrapOffsetZ, DWORD* pdwNumVerts )
  1076. {
  1077.     HRESULT hr = S_OK;
  1079.     assert( m_pMesh != NULL );
  1081.     // Setup a material
  1082.     D3DMATERIAL9 mtrl;
  1083.     ZeroMemory( &mtrl, sizeof(D3DMATERIAL9) );
  1084.     mtrl.Diffuse.r = mtrl.Ambient.r = 1.0f;
  1085.     mtrl.Diffuse.g = mtrl.Ambient.g = 1.0f;
  1086.     mtrl.Diffuse.b = mtrl.Ambient.b = 1.0f;
  1087.     mtrl.Diffuse.a = mtrl.Ambient.a = 1.0f;
  1088.     g_pd3dDevice->SetMaterial( &mtrl );
  1089.     g_pd3dDevice->SetTexture( 0, m_pTexture );
  1091.     g_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
  1092.     g_pd3dDevice->SetRenderState( D3DRS_SRCBLEND,     D3DBLEND_SRCALPHA  );
  1093.     g_pd3dDevice->SetRenderState( D3DRS_DESTBLEND,    D3DBLEND_INVSRCALPHA );
  1095.     g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE  );
  1096.     g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
  1097.     g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
  1098.     g_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_SELECTARG1  );
  1099.     g_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
  1100.     g_pd3dDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
  1102.     D3DXMatrixTranslation( &m_matWorld, fWrapOffsetX + m_fWorldOffsetX, 0.0f, fWrapOffsetZ + m_fWorldOffsetZ );
  1103.     g_pd3dDevice->SetTransform( D3DTS_WORLD, &m_matWorld );
  1105.     if( pdwNumVerts )
  1106.         *pdwNumVerts = m_pMesh->GetNumFaces();
  1108.     if( g_Profile.bRenderGround )
  1109.     {
  1110.         hr = m_pMesh->DrawSubset( 0 );
  1111.         if( FAILED(hr) )
  1112.             return DXTRACE_ERR( TEXT("DrawSubset"), hr );
  1113.     }
  1115.     return S_OK;
  1116. }
  1121. //-----------------------------------------------------------------------------
  1122. // Name: 
  1123. // Desc: 
  1124. //-----------------------------------------------------------------------------
  1125. HRESULT CTerrainMesh::InvalidateDeviceObjects()
  1126. {
  1127.     SAFE_RELEASE( m_pMesh );
  1128.     SAFE_RELEASE( m_pTexture );
  1130.     return S_OK;
  1131. }
  1136. //-----------------------------------------------------------------------------
  1137. // Name: 
  1138. // Desc: 
  1139. //-----------------------------------------------------------------------------
  1140. HRESULT CTerrainMesh::DeleteDeviceObjects()
  1141. {
  1142.     return S_OK;
  1143. }
  1148. //-----------------------------------------------------------------------------
  1149. // Name: 
  1150. // Desc: 
  1151. //-----------------------------------------------------------------------------
  1152. VOID CTerrainMesh::FinalCleanup()
  1153. {
  1154.     SAFE_DELETE( m_pMap );
  1155. }
  1160. //-----------------------------------------------------------------------------
  1161. // Name: 
  1162. // Desc: 
  1163. //-----------------------------------------------------------------------------
  1164. DWORD CTerrainMesh::GetTexelColor( DWORD iLevel, float x, float z )
  1165. {
  1166.     HRESULT hr;
  1167.     DWORD dwResult = 0;
  1169.     D3DSURFACE_DESC surfDesc;
  1170.     hr = m_pTexture->GetLevelDesc( iLevel, &surfDesc );
  1171.     
  1172.     x -= m_fWorldOffsetX;
  1173.     z -= m_fWorldOffsetZ;
  1175.     DWORD dwTexelX = (DWORD) ( x * (surfDesc.Width  / m_pMap->m_fXSize) );
  1176.     DWORD dwTexelZ = (DWORD) ( z * (surfDesc.Height / m_pMap->m_fZSize) );
  1178.     D3DLOCKED_RECT LockedRect;
  1179.     hr = m_pTexture->LockRect( iLevel, &LockedRect, NULL, 0 );
  1180.     if( FAILED(hr) )
  1181.         return DXTRACE_ERR( TEXT("LockRect"), hr );
  1183.     switch( surfDesc.Format )
  1184.     {
  1185.         case D3DFMT_A8R8G8B8:
  1186.         case D3DFMT_X8R8G8B8:
  1187.         {
  1188.             DWORD* pBits = (DWORD*) ((BYTE*)LockedRect.pBits + LockedRect.Pitch*dwTexelZ);
  1189.             pBits += dwTexelX;
  1190.             dwResult = *pBits;
  1191.             break;
  1192.         }
  1193.     }
  1195.     hr = m_pTexture->UnlockRect( iLevel );
  1196.     if( FAILED(hr) )
  1197.         return DXTRACE_ERR( TEXT("UnlockRect"), hr );   
  1199.     return dwResult;
  1200. }
  1205. //-----------------------------------------------------------------------------
  1206. // Name: 
  1207. // Desc: 
  1208. //-----------------------------------------------------------------------------
  1209. HRESULT CTerrainMesh::SaveMeshToXFile()
  1210. {
  1211. /*
  1212.     HRESULT hr;
  1214.     TCHAR strFileName[MAX_PATH];
  1215.     lstrcpy( strFileName, m_pLandStyle->szHeightMap );
  1216.     strFileName[lstrlen(strFileName)-4] = 0;
  1217.     lstrcat( strFileName, TEXT("-save.x") );
  1219.     DWORD* pdwAdjaceny  = NULL;
  1220.     pdwAdjaceny = new DWORD[ 3 * m_pMesh->GetNumFaces() ];
  1221.     if( pdwAdjaceny == NULL )
  1222.         return E_OUTOFMEMORY;
  1224.     hr = m_pMesh->GenerateAdjacency( 0.01f, pdwAdjaceny );
  1225.     if( FAILED(hr) )
  1226.         return DXTRACE_ERR( TEXT("GenerateAdjacency"), hr );
  1228.     hr = D3DXSaveMeshToX( strFileName, m_pMesh, pdwAdjaceny, NULL, 0, DXFILEFORMAT_TEXT );
  1229.     if( FAILED(hr) )
  1230.         return DXTRACE_ERR( TEXT("D3DXSaveMeshToX"), hr );
  1231.     
  1232.     SAFE_DELETE_ARRAY( pdwAdjaceny );
  1233. */  
  1234.     return S_OK;
  1235. }
  1240. //-----------------------------------------------------------------------------
  1241. // Name: 
  1242. // Desc: 
  1243. //-----------------------------------------------------------------------------
  1244. HRESULT CTerrainMesh::SaveTextureToFile()
  1245. {
  1246.     HRESULT hr;
  1248.     TCHAR strFileName[MAX_PATH];
  1249.     lstrcpy( strFileName, m_pLandStyle->szHeightMap );
  1250.     strFileName[lstrlen(strFileName)-4] = 0;
  1251.     lstrcat( strFileName, TEXT("-save.bmp") );
  1253.     hr = D3DXSaveTextureToFile( strFileName, D3DXIFF_BMP, m_pTexture, NULL );
  1254.     if( FAILED(hr) )
  1255.         return DXTRACE_ERR( TEXT("D3DXSaveTextureToFile"), hr );
  1256.     
  1257.     return S_OK;
  1258. }