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

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

游戏

开发平台：

Visual C++

TerrainEngine.cpp：源码内容
  1. //-----------------------------------------------------------------------------
  2. // File: TerrianEngine.cpp
  3. //
  4. // Copyright (C) Microsoft Corporation. All Rights Reserved.
  5. //-----------------------------------------------------------------------------
  6. #include "stdafx.h"
  11. //-----------------------------------------------------------------------------
  12. // Name: CTerrainEngine
  13. // Desc: 
  14. //-----------------------------------------------------------------------------
  15. CTerrainEngine::CTerrainEngine( CMyApplication* pApp )
  16. {
  17.     m_pApp          = pApp;
  18.     m_MeshArray     = NULL;
  19.     m_dwObjectCount = 0;
  20.     m_dwEnemyCount  = 0;
  21. }
  26. //-----------------------------------------------------------------------------
  27. // Name: ~CTerrainEngine
  28. // Desc: 
  29. //-----------------------------------------------------------------------------
  30. CTerrainEngine::~CTerrainEngine()
  31. {
  32.     FinalCleanup();
  33. }
  38. //-----------------------------------------------------------------------------
  39. // Name: OneTimeSceneInit
  40. // Desc: 
  41. //-----------------------------------------------------------------------------
  42. HRESULT CTerrainEngine::OneTimeSceneInit( CThemeStyle* pTheme )
  43. {
  44.     HRESULT hr;
  45.     int iX, iZ;
  47.     m_pTheme = pTheme;
  48.     m_dwWorldWidth  = g_Profile.nWorldWidth;
  49.     m_dwWorldHeight = g_Profile.nWorldHeight;
  51.     m_MeshArray = new MESH_NODE[ m_dwWorldWidth * m_dwWorldHeight ];
  52.     if( NULL == m_MeshArray )
  53.         return E_OUTOFMEMORY;
  54.     ZeroMemory( m_MeshArray, m_dwWorldWidth * m_dwWorldHeight * sizeof(MESH_NODE) );
  56.     for( iX = 0; iX<m_dwWorldWidth; iX++ )
  57.     {
  58.         for( iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  59.         {
  60.             m_MeshArray[iX + m_dwWorldWidth*iZ].pMesh = new CTerrainMesh( this );
  61.             if( m_MeshArray[iX + m_dwWorldWidth*iZ].pMesh == NULL )
  62.                 return E_OUTOFMEMORY;
  63.         }
  64.     }
  66.     for( iX = 0; iX<m_dwWorldWidth; iX++ )
  67.     {
  68.         for( iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  69.         {
  70.             int iNorth  = (iZ+1) % m_dwWorldHeight;
  71.             int iEast   = (iX+1) % m_dwWorldWidth;
  72.             CTerrainMesh* pNorth      = m_MeshArray[   iX+ m_dwWorldWidth*iNorth].pMesh;
  73.             CTerrainMesh* pEast       = m_MeshArray[iEast+ m_dwWorldWidth*iZ].pMesh;
  74.             CTerrainMesh* pNorthEast  = m_MeshArray[iEast+ m_dwWorldWidth*iNorth].pMesh;
  76.             CZoneStyleParameter* pLandType = &m_pTheme->aZoneStyles[ rand() % m_pTheme->nNumZoneStyles ];
  77.             
  78.             hr = m_MeshArray[iX + m_dwWorldWidth*iZ].pMesh->OneTimeSceneInit( pLandType,
  79.                                                               (float)ZONE_WIDTH*iX, (float)ZONE_HEIGHT*iZ,
  80.                                                               pNorth, pEast, pNorthEast );
  81.             if( FAILED(hr) )
  82.                 return hr;
  83.         }
  84.     }
  86.     return S_OK;
  87. }
  92. //-----------------------------------------------------------------------------
  93. // Name: InitDeviceObjects
  94. // Desc: 
  95. //-----------------------------------------------------------------------------
  96. HRESULT CTerrainEngine::InitDeviceObjects( D3DFORMAT fmtTexture )
  97. {
  98.     m_fmtTexture = fmtTexture;
  100.     HRESULT hr;
  101.     int iX, iZ;
  103.     for( iX = 0; iX<m_dwWorldWidth; iX++ )
  104.     {
  105.         for( iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  106.         {
  107.             hr = m_MeshArray[iX + m_dwWorldWidth*iZ].pMesh->InitDeviceObjects( m_fmtTexture );
  108.             if( FAILED(hr) )
  109.                 return hr;
  110.         }
  111.     }
  113.     for( iX = 0; iX<m_dwWorldWidth; iX++ )
  114.     {
  115.         for( iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  116.         {
  117.             hr = m_MeshArray[iX + m_dwWorldWidth*iZ].pMesh->SmoothMap();
  118.             if( FAILED(hr) )
  119.                 return hr;
  120.         }
  121.     }
  123.     for( iX = 0; iX<m_dwWorldWidth; iX++ )
  124.     {
  125.         for( iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  126.         {
  127.             // The smooth processes uses the bordering meshs to smooth the mesh.
  128.             // So we need lock down the results of the first step in a 2nd pass
  129.             // otherwise while smoothing a mesh the border meshs will either be already
  130.             // smoothed or not yet smoothed (depending if that mesh was already processed)
  131.             // so it creates an gfx inconsistancy unless use all unsmoothed meshes 
  132.             hr = m_MeshArray[iX + m_dwWorldWidth*iZ].pMesh->FinalizeSmooth();
  133.             if( FAILED(hr) )
  134.                 return hr;
  135.         }
  136.     }  
  138.     return S_OK;
  139. }
  144. //-----------------------------------------------------------------------------
  145. // Name: RestoreDeviceObjects
  146. // Desc: 
  147. //-----------------------------------------------------------------------------
  148. HRESULT CTerrainEngine::RestoreDeviceObjects( HWND hWndMain )
  149. {
  150.     HRESULT hr;
  151.     int iX, iZ;
  153.     for( iX = 0; iX<m_dwWorldWidth; iX++ )
  154.     {
  155.         for( iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  156.         {
  157.             MESH_NODE* pMeshNode = &m_MeshArray[iX + m_dwWorldWidth*iZ];
  159.             CDisplayObject* pObject = pMeshNode->pDisplayList;
  160.             while( pObject )
  161.             {
  162.                 pObject->RestoreDeviceObjects();
  163.                 pObject = pObject->m_pNext;
  164.             }
  166.             hr = pMeshNode->pMesh->RestoreDeviceObjects( hWndMain );
  167.             if( FAILED(hr) )
  168.                 return hr;
  169.         }
  170.     }
  172.     for( iX = 0; iX<m_dwWorldWidth; iX++ )
  173.     {
  174.         for( iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  175.         {
  176.             hr = m_MeshArray[iX + m_dwWorldWidth*iZ].pMesh->GenerateMipMaps();
  177.             if( FAILED(hr) )
  178.                 return hr;
  179.         }
  180.     }
  182.     if( m_dwWorldWidth != 1 && m_dwWorldHeight != 1 ) // Can't correct edge if its 1xN or Nx1
  183.     {
  184.         for( iX = 0; iX<m_dwWorldWidth; iX++ )
  185.         {
  186.             for( iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  187.             {
  188.                 hr = m_MeshArray[iX + m_dwWorldWidth*iZ].pMesh->CorrectTextureEdge();
  189.                 if( FAILED(hr) )
  190.                     return hr;
  191.             }
  192.         }
  193.     }
  195.     return S_OK;
  196. }
  200. //-----------------------------------------------------------------------------
  201. // Name: AddDisplayObject
  202. // Desc: 
  203. //-----------------------------------------------------------------------------
  204. HRESULT CTerrainEngine::AddDisplayObject( CDisplayObject* pObject )
  205. {
  206.     if( NULL == pObject )
  207.         return E_INVALIDARG;
  209.     int iX, iZ;
  211.     GetZoneFromPt( pObject->m_vPos.x, pObject->m_vPos.z, &iX, &iZ );
  213.     MESH_NODE* pMeshNode = &m_MeshArray[iX + m_dwWorldWidth*iZ];
  214.     if( pMeshNode->pDisplayList )
  215.     {
  216.         pObject->m_pNext = pMeshNode->pDisplayList;
  217.         pObject->m_pPrev = NULL;
  218.         pMeshNode->pDisplayList->m_pPrev = pObject;
  219.         pMeshNode->pDisplayList = pObject;
  220.     }
  221.     else
  222.     {
  223.         pMeshNode->pDisplayList = pObject;
  224.         pObject->m_pNext = NULL;
  225.         pObject->m_pPrev = NULL;
  226.     }
  228.     pObject->m_pMeshNode = pMeshNode;
  230.     if( pObject->m_ObjectType == OBJ_ENEMY )
  231.         m_dwEnemyCount++;
  232.     m_dwObjectCount++;
  234.     return S_OK;
  235. }
  239. //-----------------------------------------------------------------------------
  240. // Name: RemoveDisplayObject
  241. // Desc: 
  242. //-----------------------------------------------------------------------------
  243. HRESULT CTerrainEngine::RemoveDisplayObject( CDisplayObject* pObject )
  244. {
  245.     if( NULL == pObject )
  246.         return E_INVALIDARG;
  248.     MESH_NODE* pMeshNode = pObject->m_pMeshNode;
  250.     if( pMeshNode )
  251.     {
  252.         if( pMeshNode->pDisplayList == pObject )
  253.         {
  254.             pMeshNode->pDisplayList = pObject->m_pNext;
  255.             if( pMeshNode->pDisplayList )
  256.                 pMeshNode->pDisplayList->m_pPrev = NULL;
  257.         }
  258.         else
  259.         {
  260.             if( pObject->m_pPrev )
  261.                 pObject->m_pPrev->m_pNext = pObject->m_pNext;
  262.             if( pObject->m_pNext )
  263.                 pObject->m_pNext->m_pPrev = pObject->m_pPrev;
  264.         }
  265.     }
  267.     pObject->m_pMeshNode = NULL;
  269.     pObject->m_pNext = NULL;
  270.     pObject->m_pPrev = NULL;
  272.     if( pObject->m_ObjectType == OBJ_ENEMY )
  273.         m_dwEnemyCount--;
  274.     m_dwObjectCount--;
  276.     return S_OK;
  277. }
  282. //-----------------------------------------------------------------------------
  283. // Name: ClearStrayObjects
  284. // Desc: 
  285. //-----------------------------------------------------------------------------
  286. HRESULT CTerrainEngine::ClearStrayObjects()
  287. {
  288.     CPlayerShip* pPlayerShip = g_pApp->GetPlayerShip();
  290.     for( int iX = 0; iX<m_dwWorldWidth; iX++ )
  291.     {
  292.         for( int iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  293.         {
  294.             MESH_NODE* pMeshNode = &m_MeshArray[iX + m_dwWorldWidth*iZ];
  296.             CDisplayObject* pObject = pMeshNode->pDisplayList;
  297.             CDisplayObject* pObjectNext;
  298.             while( pObject )
  299.             {
  300.                 pObjectNext = pObject->m_pNext;
  302.                 if( pObject != pPlayerShip )
  303.                 {
  304.                     RemoveDisplayObject( pObject );
  305.                     pObject->InvalidateDeviceObjects();
  306.                     pObject->DeleteDeviceObjects();
  307.                     pObject->FinalCleanup();
  308.                     SAFE_DELETE( pObject );
  309.                 }
  311.                 pObject = pObjectNext;
  312.             }
  313.         }
  314.     }
  316.     return S_OK;
  317. }
  322. //-----------------------------------------------------------------------------
  323. // Name: FrameMove
  324. // Desc: 
  325. //-----------------------------------------------------------------------------
  326. HRESULT CTerrainEngine::FrameMove( const float fElapsedTime )
  327. {
  328.     HRESULT hr;
  330.     int iX;
  331.     for( iX = 0; iX<m_dwWorldWidth; iX++ )
  332.     {
  333.         for( int iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  334.         {
  335.             MESH_NODE* pMeshNode = &m_MeshArray[iX + m_dwWorldWidth*iZ];
  337.             CDisplayObject* pObject = pMeshNode->pDisplayList;
  338.             while( pObject )
  339.             {
  340.                 if( pObject->m_bActive )
  341.                 {
  342.                     if( !g_pApp->m_bPaused || 
  343.                         (g_pApp->m_bPaused && g_pApp->m_bDebugMode && pObject == g_pApp->GetPlayerShip()) )
  344.                     {
  345.                         pObject->FrameMove( fElapsedTime );
  346.                         HandleNearbyObjects( fElapsedTime, pObject, iX, iZ );
  347.                     }
  348.                 }
  350.                 pObject = pObject->m_pNext;
  351.             }
  353.             if( pMeshNode->pMesh )
  354.             {
  355.                 // The terrian mesh itself could animate
  356.                 if( FAILED( hr = pMeshNode->pMesh->FrameMove( fElapsedTime ) ) )
  357.                     return hr;
  358.             }
  359.         }
  360.     }
  362.     // Make sure all the objects are in the right zone after moving around
  363.     for( iX = 0; iX<m_dwWorldWidth; iX++ )
  364.     {
  365.         for( int iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  366.         {
  367.             MESH_NODE* pMeshNode = &m_MeshArray[iX + m_dwWorldWidth*iZ];
  368.             int iCurZoneX, iCurZoneZ;
  370.             CDisplayObject* pObject = pMeshNode->pDisplayList;
  371.             CDisplayObject* pObjectNext;
  373.             while( pObject )
  374.             {
  375.                 pObjectNext = pObject->m_pNext;
  377.                 if( pObject->m_bActive )
  378.                 {
  379.                     pObject->FrameMoveFinalize( fElapsedTime );
  381.                     GetZoneFromPt( pObject->m_vPos.x, pObject->m_vPos.z, 
  382.                                 &iCurZoneX, &iCurZoneZ );
  384.                     if( iCurZoneX != iX ||
  385.                         iCurZoneZ != iZ )
  386.                     {
  387.                         RemoveDisplayObject( pObject );
  388.                         AddDisplayObject( pObject );
  389.                     }
  390.                 }
  391.                 else
  392.                 {
  393.                     RemoveDisplayObject( pObject );
  394.                     pObject->InvalidateDeviceObjects();
  395.                     pObject->DeleteDeviceObjects();
  396.                     pObject->FinalCleanup();
  397.                     SAFE_DELETE( pObject );
  398.                 }
  400.                 pObject = pObjectNext;
  401.             }
  402.         }
  403.     }
  405.     return S_OK;
  406. }
  411. //-----------------------------------------------------------------------------
  412. // Name: HandleNearbyObjects
  413. // Desc: 
  414. //-----------------------------------------------------------------------------
  415. HRESULT CTerrainEngine::HandleNearbyObjects( const float fElapsedTime, CDisplayObject* pObject1, 
  416.                                              int iX, int iZ )
  417. {
  418.     MESH_NODE* pMeshNode = &m_MeshArray[iX + m_dwWorldWidth*iZ];
  420.     CDisplayObject* pObject2 = pMeshNode->pDisplayList;
  421.     while( pObject2 )
  422.     {
  423.         // Skip object2 if its that same as object1
  424.         if( pObject2 != pObject1 )
  425.         {
  426.             if( pObject2->m_bActive )
  427.                 pObject1->HandleNearbyObject( fElapsedTime, pObject2 );
  428.         }
  430.         pObject2 = pObject2->m_pNext;
  431.     }
  433.     return S_OK;
  434. }
  437. //-----------------------------------------------------------------------------
  438. // Name: DrawDotOnBuffer
  439. // Desc: 
  440. //-----------------------------------------------------------------------------
  441. void CTerrainEngine::DrawDotOnBuffer( int nCenterX, int nCenterY, D3DLOCKED_RECT* plockedRect, D3DSURFACE_DESC* pdesc, WORD wColor )
  442. {
  443.     int nSize = 5;
  445.     int nX = nCenterX;
  446.     int nY = nCenterY;
  448.     for( nY = nCenterY-nSize; nY < nCenterY+nSize; nY++ )
  449.     {
  450.         for( nX = nCenterX-nSize; nX < nCenterX+nSize; nX++ )
  451.         {
  452.             if( nX >= 0 && nY >= 0 &&
  453.                 nX < (int) pdesc->Width &&
  454.                 nY < (int) pdesc->Height )
  455.             {
  456.                 WORD* pBuffer = (WORD*) ((BYTE*)plockedRect->pBits + plockedRect->Pitch * nY + nX*sizeof(WORD)); 
  457.                 *pBuffer = wColor;
  458.             }
  459.         }
  460.     }
  461. }
  465. //-----------------------------------------------------------------------------
  466. // Name: RenderRadar
  467. // Desc: 
  468. //-----------------------------------------------------------------------------
  469. HRESULT CTerrainEngine::RenderRadar( LPDIRECT3DTEXTURE9 pRadarTexture, LPDIRECT3DTEXTURE9 pTempRadarTexture )
  470. {
  471.     HRESULT hr;
  472.     
  473.     if( g_bDebugIsZoneRenderFroze )
  474.         return S_OK; // debugging: don't render radar if camera pos froze
  476.     D3DSURFACE_DESC desc;
  477.     pTempRadarTexture->GetLevelDesc( 0, &desc ); 
  479.     D3DLOCKED_RECT lockedRect;
  480.     hr = pTempRadarTexture->LockRect( 0, &lockedRect, NULL, 0 );
  481.     if( SUCCEEDED(hr) )
  482.     {
  483.         memset( lockedRect.pBits, 0x00, 256*lockedRect.Pitch );
  485.         float fObjectX;
  486.         float fObjectY;
  487.         float fPlayerX;
  488.         float fPlayerY;
  489.         float fX;
  490.         float fY;
  491.         float fNewX;
  492.         float fNewY;
  493.         float fR;
  494.         float fAngle;
  495.         float iCopyX;
  496.         float iCopyY;
  498.         int nX = 0;
  499.         int nY = 0;
  501.         int iPlayerZoneX;
  502.         int iPlayerZoneZ;
  503.         int iPlayerWorldX;
  504.         int iPlayerWorldZ;
  506.         int iObjectZoneX;
  507.         int iObjectZoneZ;
  508.         int iObjectWorldX;
  509.         int iObjectWorldZ;
  511.         CPlayerShip* pPlayerShip = g_pApp->GetPlayerShip();
  512.         g_pTerrain->GetZoneFromPt( pPlayerShip->m_vPos.x, pPlayerShip->m_vPos.z, &iPlayerZoneX, &iPlayerZoneZ );
  513.         g_pTerrain->GetWorldFromPt( pPlayerShip->m_vPos.x, pPlayerShip->m_vPos.z, &iPlayerWorldX, &iPlayerWorldZ );
  515.         D3DXVECTOR3 vAheadLocal = D3DXVECTOR3(0.0,0.0f,1.0f);
  516.         D3DXVECTOR3 vAheadWorld;
  517.         D3DXVec3TransformNormal( &vAheadWorld, &vAheadLocal, &pPlayerShip->m_pSource->m_mOrientation ); 
  518.         float fAheadAngle = atan2f( vAheadWorld.x, vAheadWorld.z );
  520.         // Loop through every mesh in world
  521.         for( int iX = 0; iX<m_dwWorldWidth; iX++ )
  522.         {
  523.             for( int iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  524.             {
  525.                 MESH_NODE* pMeshNode = &m_MeshArray[iX + m_dwWorldWidth*iZ];
  526.                 CDisplayObject* pObject = pMeshNode->pDisplayList;
  528.                 // For every object in every mesh
  529.                 while( pObject )
  530.                 {
  531.                     if( pObject->m_ObjectType == OBJ_ENEMY )
  532.                     {       
  533.                         g_pTerrain->GetZoneFromPt( pObject->m_vPos.x, pObject->m_vPos.z, &iObjectZoneX, &iObjectZoneZ );
  534.                         g_pTerrain->GetWorldFromPt( pObject->m_vPos.x, pObject->m_vPos.z, &iObjectWorldX, &iObjectWorldZ );
  536.                         // Get coords of player & object between <0,0> and <1,1>
  537.                         fPlayerX = pPlayerShip->m_vPos.x / (float) (ZONE_WIDTH*g_pTerrain->m_dwWorldWidth);
  538.                         fPlayerY = pPlayerShip->m_vPos.z / (float) (ZONE_HEIGHT*g_pTerrain->m_dwWorldHeight);
  539.                         fObjectX = pObject->m_vPos.x / (float) (ZONE_WIDTH*g_pTerrain->m_dwWorldWidth);
  540.                         fObjectY = pObject->m_vPos.z / (float) (ZONE_HEIGHT*g_pTerrain->m_dwWorldHeight);
  542.                         assert( fPlayerX >= 0.0f && fPlayerX <= 1.0f );
  543.                         assert( fPlayerY >= 0.0f && fPlayerY <= 1.0f );
  544.                         assert( fObjectX >= 0.0f && fObjectX <= 1.0f );
  545.                         assert( fObjectY >= 0.0f && fObjectY <= 1.0f );
  547.                         // Calc position of object with player at <0,0>
  548.                         fX = fObjectX - fPlayerX;
  549.                         fY = fObjectY - fPlayerY;
  551.                         // Ship is now at (0,0) and object is between <-1,-1> and <1,1>
  552.                         assert( fX >= -1.0f && fX <= 1.0f );
  553.                         assert( fY >= -1.0f && fY <= 1.0f );
  555.                         // Since the world wraps, we might need to draw the same object 
  556.                         // multiple times, so find the min and loop to draw them all
  558.                         // Find the smallest fX,fY that's above -1.0f, -1.0f
  559.                         while( fX >= -1.0f && fX <= 1.0f ) 
  560.                                 fX -= 1.0f;
  561.                         while( fY >= -1.0f && fY <= 1.0f ) 
  562.                                 fY -= 1.0f;
  563.                         fX += 1.0f;
  564.                         fY += 1.0f;
  566.                         for( iCopyY=fY; iCopyY<= 1.0f; iCopyY += 1.0f )
  567.                         {
  568.                             for( iCopyX=fX; iCopyX<= 1.0f; iCopyX += 1.0f )
  569.                             {
  570.                                 // Get radius and angle of object point
  571.                                 fR = sqrtf( iCopyX*iCopyX + iCopyY*iCopyY );
  572.                                 fAngle = atan2f( iCopyY, iCopyX );
  574.                                 // Rotation the point based on the ship's angle 
  575.                                 fAngle += fAheadAngle;
  577.                                 // Figure out the new enemy pt
  578.                                 fNewX = cosf(fAngle) * fR;
  579.                                 fNewY = sinf(fAngle) * fR;
  581.                                 // New range is between -sqrt(2), sqrt(2)
  582.                                 assert( fNewX >= -1.42f && fNewX <= 1.42f );
  583.                                 assert( fNewY >= -1.42f && fNewY <= 1.42f );
  585.                                 // Make the range to between -1 & 1
  586.                                 fNewX /= 1.414213562373095048801688f;
  587.                                 fNewY /= 1.414213562373095048801688f;
  589.                                 assert( fNewX >= -1.0f && fNewX <= 1.0f );
  590.                                 assert( fNewY >= -1.0f && fNewY <= 1.0f );
  592.                                 // Flip the Y coord so it looks right on the overhead map
  593.                                 fNewY = -fNewY;
  595.                                 // Make new range between -0.5 & 0.5
  596.                                 fNewX /= 2.0f;
  597.                                 fNewY /= 2.0f;
  599.                                 assert( fNewX >= -0.5f && fNewX <= 0.5f );
  600.                                 assert( fNewY >= -0.5f && fNewY <= 0.5f );
  602.                                 // Make new range between 0 & 1
  603.                                 fNewX += 0.5f;
  604.                                 fNewY += 0.5f;
  606.                                 float fRangeX = (g_pTerrain->m_dwWorldWidth/2.0f);
  607.                                 float fRangeY = (g_pTerrain->m_dwWorldHeight/2.0f);
  609.                                 // Make new range between 0 & X
  610.                                 fNewX *= fRangeX;
  611.                                 fNewY *= fRangeY;
  613.                                 // Make new range between -X/2 & X/2
  614.                                 fNewX -= fRangeX/2.0f;
  615.                                 fNewY -= fRangeY/2.0f;
  617.                                 // Only allow dots close to ship, -0.5 & 0.5
  618.                                 if( fNewX >= -0.5f && fNewX <= 0.5f &&
  619.                                     fNewY >= -0.5f && fNewY <= 0.5f )
  620.                                 {
  621.                                     // Get radius and angle of enemy point
  622.                                     fR = sqrtf( fNewX*fNewX + fNewY*fNewY );
  623.                                     fAngle = atan2f( fNewY, fNewX );
  625.                                     float fAngleMin = -4.0f*D3DX_PI/4.0f;
  626.                                     float fAngleMax = fAngleMin+1.2f*D3DX_PI/4.0f;
  628.                                     // Limit the dots to a radius, and make a blind spot between fAngleMin & fAngleMax
  629.                                     if( fR < 0.45f && 
  630.                                         (!(fAngle > fAngleMin && fAngle < fAngleMax) || fR < 0.12f) )
  631.                                     {
  632.                                         // Make new range between 0 & 1
  633.                                         fNewX += 0.5f;
  634.                                         fNewY += 0.5f;
  636.                                         nX = (int) (fNewX * 256.0f);
  637.                                         nY = (int) (fNewY * 256.0f);
  639.                                         FLOAT fColor = 0.45f - fR;
  640.                                         fColor /= 0.45f;
  641.                                         BYTE nAlpha = (BYTE)(fColor * 30);
  642.                                         if( nAlpha > 0xF )
  643.                                             nAlpha = 0xF;
  645.                                         WORD wColor = (WORD) ( (nAlpha << 12) + 0x0FFF );
  647.                                         DrawDotOnBuffer( nX, nY, &lockedRect, &desc, wColor );
  648.                                     }
  649.                                 }
  650.                             }
  651.                         }
  652.                     }
  654.                     pObject = pObject->m_pNext;
  655.                 }
  656.             }
  657.         }
  659.         pTempRadarTexture->UnlockRect( 0 );
  660.     }
  662.     IDirect3DSurface9* pSurfaceSrc = NULL;
  663.     IDirect3DSurface9* pSurfaceDest = NULL;
  665.     pRadarTexture->GetSurfaceLevel( 0, &pSurfaceDest );
  666.     pTempRadarTexture->GetSurfaceLevel( 0, &pSurfaceSrc );
  667.     if( pSurfaceSrc  != NULL && 
  668.         pSurfaceDest != NULL )
  669.     {
  670.         D3DXLoadSurfaceFromSurface( pSurfaceDest, NULL, NULL, 
  671.                                     pSurfaceSrc, NULL, NULL, 
  672.                                     D3DX_FILTER_POINT, 0 );
  674.         SAFE_RELEASE( pSurfaceDest );
  675.         SAFE_RELEASE( pSurfaceSrc );
  676.     }
  678.     return S_OK;
  679. }
  684. //-----------------------------------------------------------------------------
  685. // Name: RenderFrame
  686. // Desc: 
  687. //-----------------------------------------------------------------------------
  688. HRESULT CTerrainEngine::RenderFrame( DWORD* pdwNumVerts, CD3DCamera* pCam )
  689. {
  690.     m_dwVertsRendered = 0;
  691.     m_dwNumZonesInView = 0;
  693.     switch( g_Profile.nRenderTerrianStyle )
  694.     {
  695.         case 0:
  696.         {
  697.             // Render zones (0..x,0..y)
  698.             for( int iX = 0; iX<m_dwWorldWidth; iX++ )
  699.             {
  700.                 for( int iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  701.                 {
  702.                     RenderZone( 0, 0, iX, iZ, TRUE, TRUE, FALSE );
  703.                     m_dwNumZonesInView++;
  704.                 }
  705.             }
  706.             break;
  707.         }
  709.         case 1:
  710.         {
  711.             // Render zones near camera (and behind camera)
  712.             D3DXVECTOR3 vCamEyePt    = pCam->GetEyePt();
  713.             D3DXVECTOR3 vCamLookAtPt = pCam->GetLookatPt();
  715.             D3DXVECTOR3 vX    = vCamLookAtPt - vCamEyePt;
  716.             D3DXVECTOR3 vXPerp = D3DXVECTOR3( -vX.z, vX.y, vX.x );
  717.             D3DXVec3Normalize( &vXPerp, &vXPerp );
  718.     
  719.             FLOAT       fXLen = D3DXVec3Length( &vX );
  720.             FLOAT       fYLen = (float) ( tan( pCam->GetFOV() / 2.0f ) * fXLen );
  721.             D3DXVECTOR3 vYPlus = vX + vXPerp * fYLen;
  722.             D3DXVECTOR3 vYNeg  = vX - vXPerp * fYLen;
  724.             int nArea=2;
  725.             for( int iX=-nArea; iX<=nArea; iX++ )
  726.             {
  727.                 for( int iZ=-nArea; iZ<=nArea; iZ++ )
  728.                 {
  729.                     int iZoneX, iZoneZ;
  730.                     int iWorldX, iWorldZ;
  732.                     float fZoneWrapPosX = vCamEyePt.x + iX*ZONE_WIDTH;
  733.                     float fZoneWrapPosZ = vCamEyePt.z + iZ*ZONE_HEIGHT;
  734.                     GetZoneFromPt( fZoneWrapPosX, fZoneWrapPosZ, &iZoneX, &iZoneZ );
  735.                     GetWorldFromPt( fZoneWrapPosX, fZoneWrapPosZ, &iWorldX, &iWorldZ );
  737.                     RenderZone( iWorldX, iWorldZ, iZoneX, iZoneZ, TRUE, TRUE, FALSE ); 
  738.                     m_dwNumZonesInView++;
  739.                 }
  740.             }
  741.             break;
  742.         }
  743.         
  744.         case 2:
  745.         {
  746.             // Render only the zones ahead of camera but this is 
  747.             // kind of complex since the world wraps
  748.             static D3DXVECTOR3 s_vLastCamEyePt;
  749.             static D3DXVECTOR3 s_vLastCamLookAtPt;
  750.             static CULLINFO s_vLastCullInfo;
  752.             D3DXVECTOR3 vCamEyePt    = pCam->GetEyePt();
  753.             D3DXVECTOR3 vCamLookAtPt = pCam->GetLookatPt();
  755.             if( g_bDebugFreezeZoneRender )
  756.             {
  757.                 // For debugging: allows camera for zone rendering to be frozen,
  758.                 // but allows the real camera to continue to move so the 
  759.                 // zone's that were being rendered can be inspected
  760.                 if( !g_bDebugIsZoneRenderFroze )
  761.                 {
  762.                     s_vLastCamEyePt    = vCamEyePt;
  763.                     s_vLastCamLookAtPt = vCamLookAtPt;
  764.                     s_vLastCullInfo  = g_pApp->m_cullinfo;
  765.                 }
  767.                 g_bDebugIsZoneRenderFroze = !g_bDebugIsZoneRenderFroze;
  768.                 g_bDebugFreezeZoneRender = FALSE;
  769.             }
  771.             if( g_bDebugIsZoneRenderFroze )
  772.             {
  773.                 vCamEyePt    = s_vLastCamEyePt;
  774.                 vCamLookAtPt = s_vLastCamLookAtPt;
  775.                 g_pApp->m_cullinfo = s_vLastCullInfo;
  776.             }
  778.             // Get the worlds coords for the zone where the camera is
  779.             int iCenterWorldX, iCenterWorldZ;
  780.             int iCenterZoneX, iCenterZoneZ;
  781.             GetZoneFromPt(  vCamEyePt.x, vCamEyePt.z, &iCenterZoneX, &iCenterZoneZ );
  782.             GetWorldFromPt( vCamEyePt.x, vCamEyePt.z, &iCenterWorldX, &iCenterWorldZ );
  783.             float fCenterZoneX = (float) iCenterWorldX * (ZONE_WIDTH  * m_dwWorldWidth) + iCenterZoneX*ZONE_WIDTH;
  784.             float fCenterZoneZ = (float) iCenterWorldZ * (ZONE_HEIGHT * m_dwWorldHeight) + iCenterZoneZ*ZONE_HEIGHT;
  786.             // The world wraps so track which zones are in view using m_aZoneView
  787.             ZeroMemory( m_aZoneView, sizeof(VIEW_NODE)*MAX_VIEW_ZONE_X*MAX_VIEW_ZONE_Z );
  789.             // CheckIfZoneInView() recursively checks neighbor zones to see if they are in view 
  790.             // and updates m_aZoneView as it goes and along draw the terrain for each zone in view. 
  791.             // The camera is always the center zone at m_aZoneView[MAX_VIEW_ZONE_X/2][MAX_VIEW_ZONE_Z/2]
  792.             CheckIfZoneInView( fCenterZoneX, fCenterZoneZ, MAX_VIEW_ZONE_X/2, MAX_VIEW_ZONE_Z/2 );
  794.             // Then draw the objects for each zone in view since objects may have alpha 
  795.             // and the terrian needs to be rendered first
  797.             // Render only objects in zones that are visable
  798.             for( int iX = MAX_VIEW_ZONE_X-1; iX>=0; iX-- )
  799.             {
  800.                 for( int iZ = MAX_VIEW_ZONE_Z-1; iZ>=0; iZ-- )
  801.                 {
  802.                     if( m_aZoneView[iX][iZ].bInView )
  803.                     {
  804.                         RenderZone( m_aZoneView[iX][iZ].iWorldX, m_aZoneView[iX][iZ].iWorldZ, 
  805.                                     m_aZoneView[iX][iZ].iZoneX, m_aZoneView[iX][iZ].iZoneZ, 
  806.                                     TRUE, FALSE, TRUE );
  807.                     }
  808.                 }
  809.             }
  811.             break;
  812.         }
  813.     }
  815.     *pdwNumVerts = m_dwVertsRendered;
  817.     return S_OK;
  818. }
  823. //-----------------------------------------------------------------------------
  824. // Name: CheckIfZoneInView
  825. // Desc: 
  826. //-----------------------------------------------------------------------------
  827. BOOL CTerrainEngine::CheckIfZoneInView( const float fZonePosX, const float fZonePosZ, 
  828.                                         const int iZoneIndexX, const int iZoneIndexZ )
  829. {
  830.     if( iZoneIndexX < 0 || iZoneIndexX >= MAX_VIEW_ZONE_X )
  831.         return FALSE;
  832.     if( iZoneIndexZ < 0 || iZoneIndexZ >= MAX_VIEW_ZONE_Z )
  833.         return FALSE;
  834.     
  835.     // Return if this zone point that has already been visited
  836.     VIEW_NODE* pViewNode = &m_aZoneView[iZoneIndexX][iZoneIndexZ];
  838.     if( pViewNode->bVisited )
  839.         return FALSE;
  840.     pViewNode->bVisited = TRUE;
  842.     // Update the viewnode's bounding box state if it has changed since last time
  843.     if( !pViewNode->bValid ||
  844.         pViewNode->fZonePosX != fZonePosX ||
  845.         pViewNode->fZonePosZ != fZonePosZ )
  846.     {
  847.         // Mark that this viewnode refers to the zone at (fZonePosX,fZonePosZ)
  848.         pViewNode->bValid = true;
  849.         m_aZoneView[iZoneIndexX][iZoneIndexZ].fZonePosX = fZonePosX;
  850.         m_aZoneView[iZoneIndexX][iZoneIndexZ].fZonePosZ = fZonePosZ;
  852.         // Set max & min vectors for the bound box of this zone in world coords
  853.         // Set the upper & lower height to extremes so that even if the camera 
  854.         // is looking down or up the zone is rendered
  855.         D3DXVECTOR3 vMin = D3DXVECTOR3( fZonePosX, -10.0f, fZonePosZ );
  856.         D3DXVECTOR3 vMax = D3DXVECTOR3( fZonePosX + ZONE_WIDTH, MAX_HEIGHT_OF_MAP, fZonePosZ + ZONE_HEIGHT );
  858.         // Set the bounding box for this zone in world coords
  859.         pViewNode->vecBoundsWorld[0] = D3DXVECTOR3( vMin.x, vMin.y, vMin.z ); // xyz
  860.         pViewNode->vecBoundsWorld[1] = D3DXVECTOR3( vMax.x, vMin.y, vMin.z ); // Xyz
  861.         pViewNode->vecBoundsWorld[2] = D3DXVECTOR3( vMin.x, vMax.y, vMin.z ); // xYz
  862.         pViewNode->vecBoundsWorld[3] = D3DXVECTOR3( vMax.x, vMax.y, vMin.z ); // XYz
  863.         pViewNode->vecBoundsWorld[4] = D3DXVECTOR3( vMin.x, vMin.y, vMax.z ); // xyZ
  864.         pViewNode->vecBoundsWorld[5] = D3DXVECTOR3( vMax.x, vMin.y, vMax.z ); // XyZ
  865.         pViewNode->vecBoundsWorld[6] = D3DXVECTOR3( vMin.x, vMax.y, vMax.z ); // xYZ
  866.         pViewNode->vecBoundsWorld[7] = D3DXVECTOR3( vMax.x, vMax.y, vMax.z ); // XYZ
  868.         // Calc the planes of the bounding box
  869.         D3DXPlaneFromPoints( &pViewNode->planeBoundsWorld[0], &pViewNode->vecBoundsWorld[0], &pViewNode->vecBoundsWorld[1], &pViewNode->vecBoundsWorld[2] ); // Near
  870.         D3DXPlaneFromPoints( &pViewNode->planeBoundsWorld[1], &pViewNode->vecBoundsWorld[6], &pViewNode->vecBoundsWorld[7], &pViewNode->vecBoundsWorld[5] ); // Far
  871.         D3DXPlaneFromPoints( &pViewNode->planeBoundsWorld[2], &pViewNode->vecBoundsWorld[2], &pViewNode->vecBoundsWorld[6], &pViewNode->vecBoundsWorld[4] ); // Left
  872.         D3DXPlaneFromPoints( &pViewNode->planeBoundsWorld[3], &pViewNode->vecBoundsWorld[7], &pViewNode->vecBoundsWorld[3], &pViewNode->vecBoundsWorld[5] ); // Right
  873.         D3DXPlaneFromPoints( &pViewNode->planeBoundsWorld[4], &pViewNode->vecBoundsWorld[2], &pViewNode->vecBoundsWorld[3], &pViewNode->vecBoundsWorld[6] ); // Top
  874.         D3DXPlaneFromPoints( &pViewNode->planeBoundsWorld[5], &pViewNode->vecBoundsWorld[1], &pViewNode->vecBoundsWorld[0], &pViewNode->vecBoundsWorld[4] ); // Bottom
  875.     }
  877.     // Cull the zone based on its bounding box 
  878.     pViewNode->cullstate = CullObject( &g_pApp->m_cullinfo, pViewNode->vecBoundsWorld, pViewNode->planeBoundsWorld );
  880.     // Only render this zone if its inside the camera's view
  881.     if( pViewNode->cullstate == CS_INSIDE )
  882.     {
  883.         m_aZoneView[iZoneIndexX][iZoneIndexZ].bInView = TRUE;   
  884.         m_dwNumZonesInView++;
  886.         // Since the world wraps, recursively check to see if the 8 neighbor zones are in view
  887.         CheckIfZoneInView( fZonePosX - ZONE_WIDTH, fZonePosZ              , iZoneIndexX-1, iZoneIndexZ+0 );
  888.         CheckIfZoneInView( fZonePosX + ZONE_WIDTH, fZonePosZ              , iZoneIndexX+1, iZoneIndexZ+0 );
  889.         CheckIfZoneInView( fZonePosX             , fZonePosZ - ZONE_HEIGHT, iZoneIndexX+0, iZoneIndexZ-1 );
  890.         CheckIfZoneInView( fZonePosX             , fZonePosZ + ZONE_HEIGHT, iZoneIndexX+0, iZoneIndexZ+1 );
  891.         CheckIfZoneInView( fZonePosX - ZONE_WIDTH, fZonePosZ - ZONE_HEIGHT, iZoneIndexX-1, iZoneIndexZ-1 );
  892.         CheckIfZoneInView( fZonePosX - ZONE_WIDTH, fZonePosZ + ZONE_HEIGHT, iZoneIndexX-1, iZoneIndexZ+1 );
  893.         CheckIfZoneInView( fZonePosX + ZONE_WIDTH, fZonePosZ - ZONE_HEIGHT, iZoneIndexX+1, iZoneIndexZ-1 );
  894.         CheckIfZoneInView( fZonePosX + ZONE_WIDTH, fZonePosZ + ZONE_HEIGHT, iZoneIndexX+1, iZoneIndexZ+1 );
  896.         GetZoneFromPt( fZonePosX+ZONE_WIDTH/2, fZonePosZ+ZONE_HEIGHT/2, &m_aZoneView[iZoneIndexX][iZoneIndexZ].iZoneX, &m_aZoneView[iZoneIndexX][iZoneIndexZ].iZoneZ );
  897.         GetWorldFromPt( fZonePosX+ZONE_WIDTH/2, fZonePosZ+ZONE_HEIGHT/2, &m_aZoneView[iZoneIndexX][iZoneIndexZ].iWorldX, &m_aZoneView[iZoneIndexX][iZoneIndexZ].iWorldZ );
  899.         // Render this zone
  900.         RenderZone( m_aZoneView[iZoneIndexX][iZoneIndexZ].iWorldX, m_aZoneView[iZoneIndexX][iZoneIndexZ].iWorldZ,
  901.                     m_aZoneView[iZoneIndexX][iZoneIndexZ].iZoneX, m_aZoneView[iZoneIndexX][iZoneIndexZ].iZoneZ,
  902.                     FALSE, TRUE, TRUE ); 
  903.         return TRUE;
  904.     }
  906.     return FALSE;
  907. }
  911. //-----------------------------------------------------------------------------
  912. // Name: CullObject()
  913. // Desc: Determine the cullstate for an object bounding box (OBB).  
  914. //       The algorithm is:
  915. //       1) If any OBB corner pt is inside the frustum, return CS_INSIDE
  916. //       2) Else if all OBB corner pts are outside a single frustum plane, 
  917. //          return CS_OUTSIDE
  918. //       3) Else if any frustum edge penetrates a face of the OBB, return 
  919. //          CS_INSIDE
  920. //       4) Else if any OBB edge penetrates a face of the frustum, return
  921. //          CS_INSIDE
  922. //       5) Else if any point in the frustum is outside any plane of the 
  923. //          OBB, return CS_OUTSIDE
  924. //       6) Else return CS_INSIDE
  925. //-----------------------------------------------------------------------------
  926. CULLSTATE CTerrainEngine::CullObject( const CULLINFO* pCullInfo, const D3DXVECTOR3* pVecBounds, 
  927.                                       const D3DXPLANE* pPlaneBounds )
  928. {
  929.     BYTE bOutside[8];
  930.     ZeroMemory( &bOutside, sizeof(bOutside) );
  932.     // Check boundary vertices against all 6 frustum planes, 
  933.     // and store result (1 if outside) in a bitfield
  934.     for( int iPoint = 0; iPoint < 8; iPoint++ )
  935.     {
  936.         for( int iPlane = 0; iPlane < 6; iPlane++ )
  937.         {
  938.             if( pCullInfo->planeFrustum[iPlane].a * pVecBounds[iPoint].x +
  939.                 pCullInfo->planeFrustum[iPlane].b * pVecBounds[iPoint].y +
  940.                 pCullInfo->planeFrustum[iPlane].c * pVecBounds[iPoint].z +
  941.                 pCullInfo->planeFrustum[iPlane].d < 0)
  942.             {
  943.                 bOutside[iPoint] |= (1 << iPlane);
  944.             }
  945.         }
  946.         // If any point is inside all 6 frustum planes, it is inside
  947.         // the frustum, so the object must be rendered.
  948.         if( bOutside[iPoint] == 0 )
  949.             return CS_INSIDE;
  950.     }
  952.     // If all points are outside any single frustum plane, the object is
  953.     // outside the frustum
  954.     if( (bOutside[0] & bOutside[1] & bOutside[2] & bOutside[3] & 
  955.         bOutside[4] & bOutside[5] & bOutside[6] & bOutside[7]) != 0 )
  956.     {
  957.         return CS_OUTSIDE;
  958.     }
  960.     // Now see if any of the frustum edges penetrate any of the faces of
  961.     // the bounding box
  962.     D3DXVECTOR3 edge[12][2] = 
  963.     {
  964.         pCullInfo->vecFrustum[0], pCullInfo->vecFrustum[1], // front bottom
  965.         pCullInfo->vecFrustum[2], pCullInfo->vecFrustum[3], // front top
  966.         pCullInfo->vecFrustum[0], pCullInfo->vecFrustum[2], // front left
  967.         pCullInfo->vecFrustum[1], pCullInfo->vecFrustum[3], // front right
  968.         pCullInfo->vecFrustum[4], pCullInfo->vecFrustum[5], // back bottom
  969.         pCullInfo->vecFrustum[6], pCullInfo->vecFrustum[7], // back top
  970.         pCullInfo->vecFrustum[4], pCullInfo->vecFrustum[6], // back left
  971.         pCullInfo->vecFrustum[5], pCullInfo->vecFrustum[7], // back right
  972.         pCullInfo->vecFrustum[0], pCullInfo->vecFrustum[4], // left bottom
  973.         pCullInfo->vecFrustum[2], pCullInfo->vecFrustum[6], // left top
  974.         pCullInfo->vecFrustum[1], pCullInfo->vecFrustum[5], // right bottom
  975.         pCullInfo->vecFrustum[3], pCullInfo->vecFrustum[7], // right top
  976.     };
  977.     D3DXVECTOR3 face[6][4] =
  978.     {
  979.         pVecBounds[0], pVecBounds[2], pVecBounds[3], pVecBounds[1], // front
  980.         pVecBounds[4], pVecBounds[5], pVecBounds[7], pVecBounds[6], // back
  981.         pVecBounds[0], pVecBounds[4], pVecBounds[6], pVecBounds[2], // left
  982.         pVecBounds[1], pVecBounds[3], pVecBounds[7], pVecBounds[5], // right
  983.         pVecBounds[2], pVecBounds[6], pVecBounds[7], pVecBounds[3], // top
  984.         pVecBounds[0], pVecBounds[4], pVecBounds[5], pVecBounds[1], // bottom
  985.     };
  986.     D3DXVECTOR3* pEdge;
  987.     D3DXVECTOR3* pFace;
  988.     pEdge = &edge[0][0];
  989.     for( INT iEdge = 0; iEdge < 12; iEdge++ )
  990.     {
  991.         pFace = &face[0][0];
  992.         for( INT iFace = 0; iFace < 6; iFace++ )
  993.         {
  994.             if( EdgeIntersectsFace( pEdge, pFace, &pPlaneBounds[iFace] ) )
  995.             {
  996.                 return CS_INSIDE; // slow
  997.             }
  998.             pFace += 4;
  999.         }
  1000.         pEdge += 2;
  1001.     }
  1003.     // Now see if any of the bounding box edges penetrate any of the faces of
  1004.     // the frustum
  1005.     D3DXVECTOR3 edge2[12][2] = 
  1006.     {
  1007.         pVecBounds[0], pVecBounds[1], // front bottom
  1008.         pVecBounds[2], pVecBounds[3], // front top
  1009.         pVecBounds[0], pVecBounds[2], // front left
  1010.         pVecBounds[1], pVecBounds[3], // front right
  1011.         pVecBounds[4], pVecBounds[5], // back bottom
  1012.         pVecBounds[6], pVecBounds[7], // back top
  1013.         pVecBounds[4], pVecBounds[6], // back left
  1014.         pVecBounds[5], pVecBounds[7], // back right
  1015.         pVecBounds[0], pVecBounds[4], // left bottom
  1016.         pVecBounds[2], pVecBounds[6], // left top
  1017.         pVecBounds[1], pVecBounds[5], // right bottom
  1018.         pVecBounds[3], pVecBounds[7], // right top
  1019.     };
  1020.     D3DXVECTOR3 face2[6][4] =
  1021.     {
  1022.         pCullInfo->vecFrustum[0], pCullInfo->vecFrustum[2], pCullInfo->vecFrustum[3], pCullInfo->vecFrustum[1], // front
  1023.         pCullInfo->vecFrustum[4], pCullInfo->vecFrustum[5], pCullInfo->vecFrustum[7], pCullInfo->vecFrustum[6], // back
  1024.         pCullInfo->vecFrustum[0], pCullInfo->vecFrustum[4], pCullInfo->vecFrustum[6], pCullInfo->vecFrustum[2], // left
  1025.         pCullInfo->vecFrustum[1], pCullInfo->vecFrustum[3], pCullInfo->vecFrustum[7], pCullInfo->vecFrustum[5], // right
  1026.         pCullInfo->vecFrustum[2], pCullInfo->vecFrustum[6], pCullInfo->vecFrustum[7], pCullInfo->vecFrustum[3], // top
  1027.         pCullInfo->vecFrustum[0], pCullInfo->vecFrustum[4], pCullInfo->vecFrustum[5], pCullInfo->vecFrustum[1], // bottom
  1028.     };
  1029.     pEdge = &edge2[0][0];
  1030.     for( iEdge = 0; iEdge < 12; iEdge++ )
  1031.     {
  1032.         pFace = &face2[0][0];
  1033.         for( INT iFace = 0; iFace < 6; iFace++ )
  1034.         {
  1035.             if( EdgeIntersectsFace( pEdge, pFace, &pCullInfo->planeFrustum[iFace] ) )
  1036.             {
  1037.                 return CS_INSIDE; // slow
  1038.             }
  1039.             pFace += 4;
  1040.         }
  1041.         pEdge += 2;
  1042.     }
  1044.     // Now see if frustum is contained in bounding box
  1045.     // If any frustum corner point is outside any plane of the bounding box,
  1046.     // the frustum is not contained in the bounding box, so the object
  1047.     // is outside the frustum
  1048.     for( INT iPlane = 0; iPlane < 6; iPlane++ )
  1049.     {
  1050.         if( pPlaneBounds[iPlane].a * pCullInfo->vecFrustum[0].x +
  1051.             pPlaneBounds[iPlane].b * pCullInfo->vecFrustum[0].y +
  1052.             pPlaneBounds[iPlane].c * pCullInfo->vecFrustum[0].z +
  1053.             pPlaneBounds[iPlane].d  < 0 )
  1054.         {
  1055.             return CS_OUTSIDE; // slow 
  1056.         }
  1057.     }
  1059.     // Bounding box must contain the frustum, so render the object
  1060.     return CS_INSIDE; // slow
  1061. }
  1066. //-----------------------------------------------------------------------------
  1067. // Name: EdgeIntersectsFace()
  1068. // Desc: Determine if the edge bounded by the two vectors in pEdges intersects
  1069. //       the quadrilateral described by the four vectors in pFacePoints.  
  1070. //       Note: pPlane could be derived from pFacePoints using 
  1071. //       D3DXPlaneFromPoints, but it is precomputed in advance for greater
  1072. //       speed.
  1073. //-----------------------------------------------------------------------------
  1074. BOOL CTerrainEngine::EdgeIntersectsFace( const D3DXVECTOR3* const pEdges, const D3DXVECTOR3* const pFacePoints, 
  1075.                                          const D3DXPLANE* const pPlane )
  1076. {
  1077.     // If both edge points are on the same side of the plane, the edge does
  1078.     // not intersect the face
  1079.     FLOAT fDist1;
  1080.     FLOAT fDist2;
  1081.     fDist1 = pPlane->a * pEdges[0].x + pPlane->b * pEdges[0].y +
  1082.              pPlane->c * pEdges[0].z + pPlane->d;
  1083.     fDist2 = pPlane->a * pEdges[1].x + pPlane->b * pEdges[1].y +
  1084.              pPlane->c * pEdges[1].z + pPlane->d;
  1085.     if( fDist1 > 0 && fDist2 > 0 ||
  1086.         fDist1 < 0 && fDist2 < 0 )
  1087.     {
  1088.         return FALSE;
  1089.     }
  1091.     // Find point of intersection between edge and face plane (if they're
  1092.     // parallel, edge does not intersect face and D3DXPlaneIntersectLine 
  1093.     // returns NULL)
  1094.     D3DXVECTOR3 ptIntersection;
  1095.     if( NULL == D3DXPlaneIntersectLine( &ptIntersection, pPlane, &pEdges[0], &pEdges[1] ) )
  1096.         return FALSE;
  1098.     // Project onto a 2D plane to make the pt-in-poly test easier
  1099.     FLOAT fAbsA = (pPlane->a > 0 ? pPlane->a : -pPlane->a);
  1100.     FLOAT fAbsB = (pPlane->b > 0 ? pPlane->b : -pPlane->b);
  1101.     FLOAT fAbsC = (pPlane->c > 0 ? pPlane->c : -pPlane->c);
  1102.     D3DXVECTOR2 facePoints[4];
  1103.     D3DXVECTOR2 point;
  1104.     if( fAbsA > fAbsB && fAbsA > fAbsC )
  1105.     {
  1106.         // Plane is mainly pointing along X axis, so use Y and Z
  1107.         for( INT i = 0; i < 4; i++)
  1108.         {
  1109.             facePoints[i].x = pFacePoints[i].y;
  1110.             facePoints[i].y = pFacePoints[i].z;
  1111.         }
  1112.         point.x = ptIntersection.y;
  1113.         point.y = ptIntersection.z;
  1114.     }
  1115.     else if( fAbsB > fAbsA && fAbsB > fAbsC )
  1116.     {
  1117.         // Plane is mainly pointing along Y axis, so use X and Z
  1118.         for( INT i = 0; i < 4; i++)
  1119.         {
  1120.             facePoints[i].x = pFacePoints[i].x;
  1121.             facePoints[i].y = pFacePoints[i].z;
  1122.         }
  1123.         point.x = ptIntersection.x;
  1124.         point.y = ptIntersection.z;
  1125.     }
  1126.     else
  1127.     {
  1128.         // Plane is mainly pointing along Z axis, so use X and Y
  1129.         for( INT i = 0; i < 4; i++)
  1130.         {
  1131.             facePoints[i].x = pFacePoints[i].x;
  1132.             facePoints[i].y = pFacePoints[i].y;
  1133.         }
  1134.         point.x = ptIntersection.x;
  1135.         point.y = ptIntersection.y;
  1136.     }
  1138.     // If point is on the outside of any of the face edges, it is
  1139.     // outside the face.  
  1140.     // We can do this by taking the determinant of the following matrix:
  1141.     // | x0 y0 1 |
  1142.     // | x1 y1 1 |
  1143.     // | x2 y2 1 |
  1144.     // where (x0,y0) and (x1,y1) are points on the face edge and (x2,y2) 
  1145.     // is our test point.  If this value is positive, the test point is
  1146.     // "to the left" of the line.  To determine whether a point needs to
  1147.     // be "to the right" or "to the left" of the four lines to qualify as
  1148.     // inside the face, we need to see if the faces are specified in 
  1149.     // clockwise or counter-clockwise order (it could be either, since the
  1150.     // edge could be penetrating from either side).  To determine this, we
  1151.     // do the same test to see if the third point is "to the right" or 
  1152.     // "to the left" of the line formed by the first two points.
  1153.     // See http://forum.swarthmore.edu/dr.math/problems/scott5.31.96.html
  1154.     FLOAT x0, x1, x2, y0, y1, y2;
  1155.     x0 = facePoints[0].x;
  1156.     y0 = facePoints[0].y;
  1157.     x1 = facePoints[1].x;
  1158.     y1 = facePoints[1].y;
  1159.     x2 = facePoints[2].x;
  1160.     y2 = facePoints[2].y;
  1161.     BOOL bClockwise = FALSE;
  1162.     if( x1*y2 - y1*x2 - x0*y2 + y0*x2 + x0*y1 - y0*x1 < 0 )
  1163.         bClockwise = TRUE;
  1164.     x2 = point.x;
  1165.     y2 = point.y;
  1166.     for( INT i = 0; i < 4; i++ )
  1167.     {
  1168.         x0 = facePoints[i].x;
  1169.         y0 = facePoints[i].y;
  1170.         if( i < 3 )
  1171.         {
  1172.             x1 = facePoints[i+1].x;
  1173.             y1 = facePoints[i+1].y;
  1174.         }
  1175.         else
  1176.         {
  1177.             x1 = facePoints[0].x;
  1178.             y1 = facePoints[0].y;
  1179.         }
  1180.         if( ( x1*y2 - y1*x2 - x0*y2 + y0*x2 + x0*y1 - y0*x1 > 0 ) == bClockwise )
  1181.             return FALSE;
  1182.     }
  1184.     // If we get here, the point is inside all four face edges, 
  1185.     // so it's inside the face.
  1186.     return TRUE;
  1187. }
  1192. //-----------------------------------------------------------------------------
  1193. // Name: GetZoneFromPt
  1194. // Desc: 
  1195. //-----------------------------------------------------------------------------
  1196. VOID CTerrainEngine::GetZoneFromPt( const float fX, const float fZ, int* pnZoneX, int* pnZoneZ )
  1197. {
  1198.     int iZoneX;
  1199.     int iZoneZ;
  1200.     
  1201.     if( fX >= 0.0f )
  1202.         iZoneX = (int) (fX / ZONE_WIDTH);
  1203.     else
  1204.         iZoneX = (int) (fX / ZONE_WIDTH) - 1;
  1206.     if( fZ >= 0.0f )
  1207.         iZoneZ = (int) (fZ / ZONE_HEIGHT);
  1208.     else
  1209.         iZoneZ = (int) (fZ / ZONE_HEIGHT) - 1;
  1211.     while( iZoneX < 0 )
  1212.         iZoneX += m_dwWorldWidth;
  1213.     while( iZoneZ < 0 )
  1214.         iZoneZ += m_dwWorldHeight;
  1216.     *pnZoneX = iZoneX % m_dwWorldWidth;
  1217.     *pnZoneZ = iZoneZ % m_dwWorldHeight;
  1218. }
  1223. //-----------------------------------------------------------------------------
  1224. // Name: GetWorldFromPt
  1225. // Desc: 
  1226. //-----------------------------------------------------------------------------
  1227. VOID CTerrainEngine::GetWorldFromPt( const float fX, const float fZ, int* pnWorldX, int* pnWorldZ )
  1228. {
  1229.     int iWorldX, iWorldZ;
  1230.     
  1231.     if( fX >= 0.0f )
  1232.         iWorldX = (int) ( fX / (ZONE_WIDTH  * m_dwWorldWidth) );
  1233.     else
  1234.         iWorldX = (int) ( fX / (ZONE_WIDTH  * m_dwWorldWidth) ) - 1;
  1236.     if( fZ >= 0.0f )
  1237.         iWorldZ = (int) ( fZ / (ZONE_HEIGHT * m_dwWorldHeight) );
  1238.     else
  1239.         iWorldZ = (int) ( fZ / (ZONE_HEIGHT * m_dwWorldHeight) ) - 1;
  1241.     *pnWorldX = iWorldX;
  1242.     *pnWorldZ = iWorldZ;
  1243. }
  1248. //-----------------------------------------------------------------------------
  1249. // Name: GetWorldFromUniversal
  1250. // Desc: output coords that are between <0,0> and 
  1251. //       <ZONE_WIDTH*m_dwWorldWidth,ZONE_HEIGHT*m_dwWorldHeight>
  1252. //-----------------------------------------------------------------------------
  1253. VOID CTerrainEngine::GetWorldFromUniversal( float fUniversalX, float fUniversalZ, 
  1254.                                             float* pfWorldX, float* pfWorldZ )
  1255. {
  1256.     // Wrap if needed
  1257.     while( fUniversalX < 0.0f )
  1258.         fUniversalX += ZONE_WIDTH*m_dwWorldWidth;
  1259.     while( fUniversalX >= ZONE_WIDTH*m_dwWorldWidth )
  1260.         fUniversalX -= ZONE_WIDTH*m_dwWorldWidth;
  1262.     while( fUniversalZ < 0.0f )
  1263.         fUniversalZ += ZONE_HEIGHT*m_dwWorldHeight;
  1264.     while( fUniversalZ >= ZONE_HEIGHT*m_dwWorldHeight )
  1265.         fUniversalZ -= ZONE_HEIGHT*m_dwWorldHeight;
  1267.     *pfWorldX = fUniversalX;
  1268.     *pfWorldZ = fUniversalZ;
  1269. }
  1274. //-----------------------------------------------------------------------------
  1275. // Name: RenderZone
  1276. // Desc: 
  1277. //-----------------------------------------------------------------------------
  1278. VOID CTerrainEngine::RenderZone( int iWorldX, int iWorldZ, int iZoneX, int iZoneZ, 
  1279.                                  BOOL bRenderObjects, BOOL bRenderTerrain, BOOL bCullObjects )
  1280. {
  1281.     float fWrapOffsetX = (float) iWorldX * (ZONE_WIDTH  * m_dwWorldWidth);
  1282.     float fWrapOffsetZ = (float) iWorldZ * (ZONE_HEIGHT * m_dwWorldHeight);
  1284.     MESH_NODE* pMeshNode = &m_MeshArray[iZoneX + m_dwWorldWidth*iZoneZ];
  1286.     if( bRenderTerrain && pMeshNode->pMesh )
  1287.     {
  1288.         DWORD dwNumTerrainVerts;
  1289.         // Set either wireframe or solid
  1290.         if( g_pApp->m_bDebugMode && g_pApp->m_bWireMode )
  1291.             g_pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME );
  1292.         else
  1293.             g_pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );
  1295.         pMeshNode->pMesh->RenderFrame( fWrapOffsetX, fWrapOffsetZ, &dwNumTerrainVerts );  
  1297.         g_pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );
  1298.         m_dwVertsRendered += dwNumTerrainVerts;
  1299.     }
  1301.     if( bRenderObjects )
  1302.     {
  1303.         DWORD dwNumModelVerts = 0;
  1305.         CDisplayObject* pObject = pMeshNode->pDisplayList;
  1306.         while( pObject )
  1307.         {
  1308.             if( pObject->m_bActive )
  1309.             {
  1310.                 bool bRender = true;
  1311.                 if( bCullObjects )
  1312.                 {
  1313.                     // Only render if m_cullstate == CS_INSIDE
  1314.                     pObject->CullObject( fWrapOffsetX, fWrapOffsetZ, &g_pApp->m_cullinfo );
  1315.                     bRender = (pObject->m_cullstate == CS_INSIDE );
  1316.                 }
  1318.                 if( bRender )
  1319.                     pObject->Render( fWrapOffsetX, fWrapOffsetZ, &dwNumModelVerts );
  1320.             }
  1321.             m_dwVertsRendered += dwNumModelVerts;
  1322.             pObject = pObject->m_pNext;
  1323.         }
  1324.     }
  1325. }
  1330. //-----------------------------------------------------------------------------
  1331. // Name: InvalidateDeviceObjects
  1332. // Desc: 
  1333. //-----------------------------------------------------------------------------
  1334. HRESULT CTerrainEngine::InvalidateDeviceObjects()
  1335. {
  1336.     HRESULT hr;
  1338.     for( int iX = 0; iX<m_dwWorldWidth; iX++ )
  1339.     {
  1340.         for( int iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  1341.         {
  1342.             MESH_NODE* pMeshNode = &m_MeshArray[iX + m_dwWorldWidth*iZ];
  1344.             CDisplayObject* pObject = pMeshNode->pDisplayList;
  1345.             while( pObject )
  1346.             {
  1347.                 pObject->InvalidateDeviceObjects();
  1348.                 pObject = pObject->m_pNext;
  1349.             }
  1351.             hr = pMeshNode->pMesh->InvalidateDeviceObjects();
  1352.             if( FAILED(hr) )
  1353.                 return hr;
  1354.         }
  1355.     }
  1357.     return S_OK;
  1358. }
  1363. //-----------------------------------------------------------------------------
  1364. // Name: DeleteDeviceObjects
  1365. // Desc: 
  1366. //-----------------------------------------------------------------------------
  1367. HRESULT CTerrainEngine::DeleteDeviceObjects()
  1368. {
  1369.     HRESULT hr;
  1371.     for( int iX = 0; iX<m_dwWorldWidth; iX++ )
  1372.     {
  1373.         for( int iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  1374.         {
  1375.             MESH_NODE* pMeshNode = &m_MeshArray[iX + m_dwWorldWidth*iZ];
  1377.             CDisplayObject* pObject = pMeshNode->pDisplayList;
  1378.             while( pObject )
  1379.             {
  1380.                 pObject->DeleteDeviceObjects();
  1381.                 pObject = pObject->m_pNext;
  1382.             }
  1384.             hr = pMeshNode->pMesh->DeleteDeviceObjects();
  1385.             if( FAILED(hr) )
  1386.                 return hr;
  1387.         }
  1388.     }
  1390.     return S_OK;
  1391. }
  1396. //-----------------------------------------------------------------------------
  1397. // Name: FinalCleanup
  1398. // Desc: 
  1399. //-----------------------------------------------------------------------------
  1400. VOID CTerrainEngine::FinalCleanup()
  1401. {
  1402.     if( m_MeshArray )
  1403.     {
  1404.         for( int iX = 0; iX<m_dwWorldWidth; iX++ )
  1405.         {
  1406.             for( int iZ = 0; iZ<m_dwWorldHeight; iZ++ )
  1407.             {
  1408.                 MESH_NODE* pMeshNode = &m_MeshArray[iX + m_dwWorldWidth*iZ];
  1410.                 CDisplayObject* pObject = pMeshNode->pDisplayList;
  1411.                 CDisplayObject* pObjectDelete;
  1412.                 while( pObject )
  1413.                 {
  1414.                     pObjectDelete = pObject;
  1415.                     pObject = pObject->m_pNext;
  1416.                     SAFE_DELETE( pObjectDelete );
  1417.                 }
  1418.                 pMeshNode->pDisplayList = NULL;
  1420.                 if( m_MeshArray[iX + m_dwWorldWidth*iZ].pMesh )
  1421.                     m_MeshArray[iX + m_dwWorldWidth*iZ].pMesh->FinalCleanup();
  1422.                 SAFE_DELETE( m_MeshArray[iX + m_dwWorldWidth*iZ].pMesh );
  1423.             }
  1424.         }
  1426.         SAFE_DELETE_ARRAY( m_MeshArray );
  1427.     }
  1428. }
  1433. //-----------------------------------------------------------------------------
  1434. // Name: GetHeight
  1435. // Desc: returns the height of the ground at this point in universial coords 
  1436. //       Since the terrian engine is simple, there can only be one 1 ground height
  1437. //       at every point (no tunnels/etc)
  1438. //-----------------------------------------------------------------------------
  1439. FLOAT CTerrainEngine::GetHeight( float x, float z ) 
  1440. { 
  1441.     // Doing this:
  1442.     // x = -0.0000001
  1443.     // x += 256.0f
  1444.     // x will equal 256.0f (it will loose bits of percision) which will throw 
  1445.     // off the calculations below so round off the percision while maintaining
  1446.     // the sign value
  1447.     x *= 10000.0f;
  1448.     if( x < 0 )
  1449.         x = floorf(x)/10000.0f;
  1450.     else
  1451.         x = ceilf(x)/10000.0f;
  1453.     z *= 10000.0f;
  1454.     if( z < 0 )
  1455.         z = floorf(z)/10000.0f;
  1456.     else
  1457.         z = ceilf(z)/10000.0f;
  1459.     // Figure out which zone this point is in
  1460.     int iX = (int)( (int)(x) / (int)ZONE_WIDTH );
  1461.     int iZ = (int)( (int)(z) / (int)ZONE_HEIGHT );
  1463.     // Compensate for negative values since iX = -10.0f / 64.0f = 0 
  1464.     // and we want iX=-1 if x=-10.0f
  1465.     if( x < 0.0f ) iX--;
  1466.     if( z < 0.0f ) iZ--;
  1468.     // Wrap the values around the world if needed
  1469.     while( iX < 0 )
  1470.     {
  1471.         iX += m_dwWorldWidth;
  1472.         x += ZONE_WIDTH*m_dwWorldWidth;
  1473.     }
  1474.     while( iX >= m_dwWorldWidth )
  1475.     {
  1476.         iX -= m_dwWorldWidth;
  1477.         x -= ZONE_WIDTH*m_dwWorldWidth;
  1478.     }
  1480.     while( iZ < 0 )
  1481.     {
  1482.         iZ += m_dwWorldHeight;
  1483.         z += ZONE_HEIGHT*m_dwWorldHeight;
  1484.     }   
  1485.     while( iZ >= m_dwWorldHeight )
  1486.     {
  1487.         iZ -= m_dwWorldHeight;
  1488.         z -= ZONE_HEIGHT*m_dwWorldHeight;
  1489.     }
  1491.     CTerrainMesh* pMesh = m_MeshArray[iX + m_dwWorldWidth*iZ].pMesh;
  1493.     // Ensure that the mesh owns this point
  1494.     assert( FALSE == pMesh->IsOutOfRangeWorld( x, z ) );       
  1496.     // Now that we know the mesh index, ask the mesh what the value is at this point
  1497.     return pMesh->GetHeightWorld( x, z ); 
  1498. };
  1503. //-----------------------------------------------------------------------------
  1504. // Name: GetTexelColor
  1505. // Desc: same as above but returns the texel color at this point
  1506. //-----------------------------------------------------------------------------
  1507. DWORD CTerrainEngine::GetTexelColor( DWORD iLevel, float x, float z )
  1508. { 
  1509.     x *= 10000.0f;
  1510.     if( x < 0 )
  1511.         x = floorf(x)/10000.0f;
  1512.     else
  1513.         x = ceilf(x)/10000.0f;
  1515.     z *= 10000.0f;
  1516.     if( z < 0 )
  1517.         z = floorf(z)/10000.0f;
  1518.     else
  1519.         z = ceilf(z)/10000.0f;
  1521.     int iX = (int)( x / (float) ZONE_WIDTH );
  1522.     int iZ = (int)( z / (float) ZONE_HEIGHT );
  1524.     if( x < 0.0f ) iX--;
  1525.     if( z < 0.0f ) iZ--;
  1527.     while( iX < 0 )
  1528.     {
  1529.         iX += m_dwWorldWidth;
  1530.         x += ZONE_WIDTH*m_dwWorldWidth;
  1531.     }
  1532.     while( iX >= m_dwWorldWidth )
  1533.     {
  1534.         iX -= m_dwWorldWidth;
  1535.         x -= ZONE_WIDTH*m_dwWorldWidth;
  1536.     }
  1538.     while( iZ < 0 )
  1539.     {
  1540.         iZ += m_dwWorldHeight;
  1541.         z += ZONE_HEIGHT*m_dwWorldHeight;
  1542.     }   
  1543.     while( iZ >= m_dwWorldHeight )
  1544.     {
  1545.         iZ -= m_dwWorldHeight;
  1546.         z -= ZONE_HEIGHT*m_dwWorldHeight;
  1547.     }
  1548.         
  1549.     return m_MeshArray[iX + m_dwWorldWidth*iZ].pMesh->GetTexelColor( iLevel, x, z ); 
  1550. }