LGram16
dd97ddec92
Move git root from Client/ to src/ to track all source code: - Client: Game client source (moved to Client/Client/) - Server: Game server source - GameTools: Development tools - CryptoSource: Encryption utilities - database: Database scripts - Script: Game scripts - rylCoder_16.02.2008_src: Legacy coder tools - GMFont, Game: Additional resources 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
2699 lines
89 KiB
C++
2699 lines
89 KiB
C++
// HeightFieldScene.cpp: implementation of the CHeightFieldScene class.
|
||
//
|
||
//////////////////////////////////////////////////////////////////////
|
||
|
||
#include "HeightFieldScene.h"
|
||
#include "SceneManager.h"
|
||
#include <BaseGraphicsLayer.h>
|
||
#include "RenderOption.h"
|
||
#include "SceneStateMgr.h"
|
||
|
||
inline DWORD F2DW( FLOAT f ) { return *((DWORD*)&f); }
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Construction/Destruction
|
||
//////////////////////////////////////////////////////////////////////
|
||
|
||
|
||
CHeightFieldScene::CHeightFieldScene()
|
||
{
|
||
//LogMessage("Constructor HeightFieldScene");
|
||
m_NowPositionX=-100000000;
|
||
m_NowPositionY=-100000000;
|
||
m_NowTessellatePosX=-100000000;
|
||
m_NowTessellatePosY=-100000000;
|
||
//LogMessage("Constructor HeightFieldScene Complete");
|
||
|
||
|
||
// 03.03.04 House and Effect and object Culling flag
|
||
|
||
m_bHouseCulling = true;
|
||
m_bObjectCulling = true;
|
||
m_bEffectCulling = true;
|
||
|
||
|
||
m_pSectorSorts = NULL;
|
||
m_iSortsNum = 0;
|
||
|
||
|
||
}
|
||
|
||
CHeightFieldScene::~CHeightFieldScene()
|
||
{
|
||
delete [] m_SectorScene;
|
||
if(m_pSectorSorts != NULL)
|
||
{
|
||
delete[] m_pSectorSorts;
|
||
m_pSectorSorts = NULL;
|
||
}
|
||
|
||
}
|
||
|
||
void CHeightFieldScene::CheckingNextTerrain()
|
||
{
|
||
vector3 *ViewPos;
|
||
vector3 CharPos;
|
||
if(CSceneManager::m_ViewerMode==0 || CSceneManager::m_ViewerMode==2)
|
||
ViewPos=CSceneManager::GetCamera()->GetPosition();
|
||
else
|
||
{
|
||
if( CSceneManager::m_CharacterManager.m_CharacterList.num == 0 )
|
||
{
|
||
ViewPos=CSceneManager::GetCamera()->GetPosition();
|
||
}
|
||
else
|
||
{
|
||
CSceneManager::m_CharacterManager.m_CharacterList[0].m_pChrmodel->GetPosition(CharPos.x,CharPos.y,CharPos.z);
|
||
//CSceneManager::m_CharacterList[0]->GetPosition(CharPos.x,CharPos.y,CharPos.z);
|
||
ViewPos=&CharPos;
|
||
}
|
||
}
|
||
|
||
|
||
int UpdatePositionX=(int)(ViewPos->x/SECTORSIZE);
|
||
int UpdatePositionY=(int)(ViewPos->z/SECTORSIZE);
|
||
if(ViewPos->x < 0.0f)
|
||
UpdatePositionX--;
|
||
if(ViewPos->z < 0.0f)
|
||
UpdatePositionY--;
|
||
|
||
if( m_NowPositionX == UpdatePositionX &&
|
||
m_NowPositionY == UpdatePositionY) return;
|
||
int WillX=(int)(ViewPos->x/SECTORSIZE);
|
||
int WillY=(int)(ViewPos->z/SECTORSIZE);
|
||
int MoveX=m_NowPositionX-WillX;
|
||
int MoveY=m_NowPositionY-WillY;
|
||
/*
|
||
int UpdateSector[LSIZEX*LSIZEY];
|
||
int NotUpdateSector[LSIZEX*LSIZEY];
|
||
*/
|
||
int *UpdateSector=new int[m_LSizeX*m_LSizeY];
|
||
int *NotUpdateSector=new int[m_LSizeX*m_LSizeY];
|
||
int CountUpdate=0;
|
||
|
||
memset(NotUpdateSector,-1,sizeof(int)*m_LSizeX*m_LSizeY);
|
||
|
||
int sectorx,sectory;
|
||
int fx,fy;
|
||
int ix,iy;
|
||
memset(m_QuadSector,0,sizeof(m_QuadSector));
|
||
///*
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
sectorx=(int)(m_SectorScene[ix+iy*m_LSizeX].m_TM._41/SECTORSIZE);
|
||
sectory=(int)(m_SectorScene[ix+iy*m_LSizeX].m_TM._43/SECTORSIZE);
|
||
|
||
if( (sectorx >= WillX-(int)(m_LSizeX/2) && sectorx <= WillX+(int)(m_LSizeX/2)) &&
|
||
(sectory >= WillY-(int)(m_LSizeY/2) && sectory <= WillY+(int)(m_LSizeY/2))
|
||
)
|
||
{
|
||
fx=sectorx-WillX+(int)(m_LSizeX/2);
|
||
fy=sectory-WillY+(int)(m_LSizeY/2);
|
||
NotUpdateSector[fx+fy*m_LSizeX]=0;
|
||
m_QuadSector[fx+fy*m_LSizeX]=&m_SectorScene[ix+iy*m_LSizeX];
|
||
}
|
||
else UpdateSector[CountUpdate++]=ix+iy*m_LSizeX;
|
||
}
|
||
}
|
||
if(CountUpdate != m_LSizeX*m_LSizeY)
|
||
{
|
||
UpdateSector[CountUpdate]=-1;
|
||
}
|
||
|
||
for(int cSector=0;cSector<m_LSizeX*m_LSizeY;cSector++)
|
||
{
|
||
sectorx=(int)(m_SectorScene[cSector].m_TM._41/SECTORSIZE);
|
||
sectory=(int)(m_SectorScene[cSector].m_TM._43/SECTORSIZE);
|
||
|
||
if( !(UpdatePositionX <= sectorx+1 &&
|
||
UpdatePositionX >= sectorx-1 &&
|
||
UpdatePositionY <= sectory+1 &&
|
||
UpdatePositionY >= sectory-1))
|
||
{
|
||
if(m_SectorScene[cSector].m_ShadowUsed!=-1)
|
||
{
|
||
m_SectorScene[cSector].m_UsedShadowTerrain[m_SectorScene[cSector].m_ShadowUsed]=-1;
|
||
m_SectorScene[cSector].m_ShadowUsed=-1;
|
||
}
|
||
}
|
||
}
|
||
|
||
int InnerCount=0;
|
||
int CheckEndUpdate=0;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(NotUpdateSector[ix+iy*m_LSizeX]==-1)
|
||
{
|
||
CheckEndUpdate=UpdateSector[InnerCount++];
|
||
if(CheckEndUpdate==-1)
|
||
break;
|
||
m_SectorScene[CheckEndUpdate].Generate(
|
||
(ix+WillX-(int)(m_LSizeX/2))*SECTORSIZE,
|
||
(iy+WillY-(int)(m_LSizeY/2))*SECTORSIZE);
|
||
m_QuadSector[ix+iy*m_LSizeX]=&m_SectorScene[CheckEndUpdate];
|
||
}
|
||
if(CheckEndUpdate==-1)break;
|
||
}
|
||
}
|
||
/*
|
||
|
||
for(int cSector=0;cSector<m_LSizeX*m_LSizeY;cSector++)
|
||
{
|
||
sectorx=(int)(m_SectorScene[cSector].m_TM._41/SECTORSIZE);
|
||
sectory=(int)(m_SectorScene[cSector].m_TM._43/SECTORSIZE);
|
||
|
||
if( !(UpdatePositionX <= sectorx+1 &&
|
||
UpdatePositionX >= sectorx-1 &&
|
||
UpdatePositionY <= sectory+1 &&
|
||
UpdatePositionY >= sectory-1))
|
||
{
|
||
if(m_SectorScene[cSector].m_ShadowUsed!=-1)
|
||
{
|
||
m_SectorScene[cSector].m_UsedShadowTerrain[m_SectorScene[cSector].m_ShadowUsed]=-1;
|
||
m_SectorScene[cSector].m_ShadowUsed=-1;
|
||
m_SectorScene[cSector].GenerateWideMap();
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
|
||
for(cSector=0;cSector<m_LSizeX*m_LSizeY;cSector++)
|
||
{
|
||
sectorx=(int)(m_SectorScene[cSector].m_TM._41/SECTORSIZE);
|
||
sectory=(int)(m_SectorScene[cSector].m_TM._43/SECTORSIZE);
|
||
|
||
if( UpdatePositionX <= sectorx+1 &&
|
||
UpdatePositionX >= sectorx-1 &&
|
||
UpdatePositionY <= sectory+1 &&
|
||
UpdatePositionY >= sectory-1)
|
||
{
|
||
if(SHADOWSIZE!=0)
|
||
m_SectorScene[cSector].GenerateShadow(BaseGraphicsLayer::GetDevice());
|
||
else
|
||
m_SectorScene[cSector].GenerateWideMap();
|
||
}
|
||
else
|
||
{
|
||
if(m_SectorScene[cSector].m_ShadowUsed!=-1)
|
||
{
|
||
m_SectorScene[cSector].m_UsedShadowTerrain[m_SectorScene[cSector].m_ShadowUsed]=-1;
|
||
m_SectorScene[cSector].m_ShadowUsed=-1;
|
||
m_SectorScene[cSector].GenerateWideMap();
|
||
}
|
||
}
|
||
}
|
||
m_NowPositionX=UpdatePositionX;
|
||
m_NowPositionY=UpdatePositionY;
|
||
delete [] UpdateSector;
|
||
delete [] NotUpdateSector;
|
||
}
|
||
|
||
void CHeightFieldScene::Create(int LSizeX,int LSizeY,CMapStorage *pMapStorage)
|
||
{
|
||
//LogMessage("HeightFieldScene Create");
|
||
m_LSizeX=LSizeX;
|
||
m_LSizeY=LSizeY;
|
||
int ix,iy;
|
||
m_SectorScene=new CSectorScene[m_LSizeX*m_LSizeY];
|
||
//m_QuadSector=new CSectorScene[m_LSizeX*m_LSizeY];
|
||
m_pSectorSorts = new SectorSortNode_t[m_LSizeX*m_LSizeY];
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].Create(pMapStorage);
|
||
}
|
||
}
|
||
m_SectorScene->m_NextTriNode=0;
|
||
m_SectorScene->m_WaterScene.Create();
|
||
m_GrassSceneManager.Create();
|
||
//LogMessage("HeightFieldScene Create Complete");
|
||
//m_GrassScene.
|
||
}
|
||
void CHeightFieldScene::RenderBlackWater(LPDIRECT3DDEVICE8 pd3dDevice) {
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
bool *IsCulling=new bool[m_LSizeX*m_LSizeY];
|
||
int ix,iy;
|
||
CSceneManager::m_cRenderSector=0;
|
||
|
||
vector3 vecMinBox,vecMaxBox;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMinBox.y;
|
||
vecMaxBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMaxBox.y;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
//if(m_SectorScene[ix+iy*m_LSizeX].isCulling())
|
||
if( CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumTop,-CSceneManager::GetCamera()->m_vecFrustumNormal[0],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumBottom,-CSceneManager::GetCamera()->m_vecFrustumNormal[1],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumLeft,-CSceneManager::GetCamera()->m_vecFrustumNormal[2],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumRight,-CSceneManager::GetCamera()->m_vecFrustumNormal[3],vecMaxBox,vecMinBox) < 0.0f)
|
||
{
|
||
|
||
IsCulling[ix+iy*m_LSizeX]=true;
|
||
CSceneManager::m_cRenderSector++;
|
||
}
|
||
else
|
||
{
|
||
IsCulling[ix+iy*m_LSizeX]=false;
|
||
}
|
||
}
|
||
}
|
||
|
||
vector3 *vecViewPos=CSceneManager::GetCamera()->GetPosition();
|
||
|
||
//pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
//pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_TerrainLight);
|
||
|
||
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
pd3dDevice->LightEnable(1,FALSE);
|
||
pd3dDevice->LightEnable(2,FALSE);
|
||
pd3dDevice->LightEnable(3,FALSE);
|
||
pd3dDevice->LightEnable(4,FALSE);
|
||
pd3dDevice->LightEnable(5,FALSE);
|
||
pd3dDevice->LightEnable(6,FALSE);
|
||
pd3dDevice->LightEnable(7,FALSE);
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
color TerrainColor;
|
||
TerrainColor.a=0xff;
|
||
TerrainColor.r=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.r*255;
|
||
TerrainColor.g=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.g*255;
|
||
TerrainColor.b=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.b*255;
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,TerrainColor.c);
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterTerrainColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 2 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 3, D3DTSS_TEXCOORDINDEX, 3 );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
|
||
|
||
|
||
/**/
|
||
/* */
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_MapWater)
|
||
{
|
||
|
||
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_MapWater->m_bWaterRelection )
|
||
m_SectorScene[ix+iy*m_LSizeX].m_WaterScene.DeterminWaterTexture(pd3dDevice,true);
|
||
else
|
||
m_SectorScene[ix+iy*m_LSizeX].m_WaterScene.DeterminWaterTexture(pd3dDevice,false);
|
||
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderBlackWater(pd3dDevice,false);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
void CHeightFieldScene::RenderWater(LPDIRECT3DDEVICE8 pd3dDevice) {
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
bool *IsCulling=new bool[m_LSizeX*m_LSizeY];
|
||
int ix,iy;
|
||
CSceneManager::m_cRenderSector=0;
|
||
|
||
vector3 vecMinBox,vecMaxBox;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMinBox.y;
|
||
vecMaxBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMaxBox.y;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
//if(m_SectorScene[ix+iy*m_LSizeX].isCulling())
|
||
if( CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumTop,-CSceneManager::GetCamera()->m_vecFrustumNormal[0],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumBottom,-CSceneManager::GetCamera()->m_vecFrustumNormal[1],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumLeft,-CSceneManager::GetCamera()->m_vecFrustumNormal[2],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumRight,-CSceneManager::GetCamera()->m_vecFrustumNormal[3],vecMaxBox,vecMinBox) < 0.0f)
|
||
{
|
||
|
||
IsCulling[ix+iy*m_LSizeX]=true;
|
||
CSceneManager::m_cRenderSector++;
|
||
}
|
||
else
|
||
{
|
||
IsCulling[ix+iy*m_LSizeX]=false;
|
||
}
|
||
}
|
||
}
|
||
|
||
vector3 *vecViewPos=CSceneManager::GetCamera()->GetPosition();
|
||
|
||
//pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
//pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_TerrainLight);
|
||
|
||
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
pd3dDevice->LightEnable(1,FALSE);
|
||
pd3dDevice->LightEnable(2,FALSE);
|
||
pd3dDevice->LightEnable(3,FALSE);
|
||
pd3dDevice->LightEnable(4,FALSE);
|
||
pd3dDevice->LightEnable(5,FALSE);
|
||
pd3dDevice->LightEnable(6,FALSE);
|
||
pd3dDevice->LightEnable(7,FALSE);
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
color TerrainColor;
|
||
TerrainColor.a=0xff;
|
||
TerrainColor.r=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.r*255;
|
||
TerrainColor.g=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.g*255;
|
||
TerrainColor.b=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.b*255;
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,TerrainColor.c);
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterTerrainColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 2 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 3, D3DTSS_TEXCOORDINDEX, 3 );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
|
||
|
||
|
||
/**/
|
||
/* */
|
||
if(CRenderOption::m_bWaterBump) {
|
||
bool bUpdate = false;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_MapWater)
|
||
{
|
||
bUpdate = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if(bUpdate == true)
|
||
break;
|
||
}
|
||
|
||
|
||
static DWORD ftime = timeGetTime();
|
||
DWORD fFtime = timeGetTime();
|
||
|
||
if(((fFtime - ftime) > 30) && (bUpdate == true)) {
|
||
CWaterScene::m_pWaterTexGenerator->Update();
|
||
ftime = fFtime;
|
||
}
|
||
}
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_MapWater)
|
||
{
|
||
|
||
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_MapWater->m_bWaterRelection )
|
||
m_SectorScene[ix+iy*m_LSizeX].m_WaterScene.DeterminWaterTexture(pd3dDevice,true);
|
||
else
|
||
m_SectorScene[ix+iy*m_LSizeX].m_WaterScene.DeterminWaterTexture(pd3dDevice,false);
|
||
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderWater(pd3dDevice,false);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
void CHeightFieldScene::RenderMinimap(LPDIRECT3DDEVICE8 pd3dDevice)
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_FOGENABLE,FALSE);
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
|
||
if(CSceneManager::m_pBspScene)
|
||
{
|
||
pd3dDevice->SetTransform(D3DTS_WORLD,CSceneManager::m_pBspScene->m_AccumulateTM);
|
||
|
||
matrix matHousePos;
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,matHousePos);
|
||
|
||
matrix *matViewPosition=CSceneManager::GetCamera()->GetMatPosition();
|
||
|
||
matrix matViewPos;
|
||
vector3 vecViewPos=matViewPosition->GetLoc();
|
||
matViewPos.Translation(vecViewPos);
|
||
|
||
matrix matInvTM,matPos;
|
||
matInvTM.Inverse(matHousePos);
|
||
|
||
matPos=matViewPos*matInvTM;
|
||
|
||
CSceneManager::m_pBspScene->m_HouseObject->m_pBspObject->Render(pd3dDevice,matPos.GetLoc());
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
if(CSceneManager::m_pBspScene->m_HouseObject->m_pBspObject->m_bSkyRender==false)
|
||
return;
|
||
//CSceneManager::m_pBspScene->Render(pd3dDevice);
|
||
}
|
||
// WaterReflection Count
|
||
List<float> WaterHeightList;
|
||
int cDrawTerr=0;
|
||
//bool IsCulling[LSIZEX*LSIZEY];
|
||
bool *IsCulling=new bool[m_LSizeX*m_LSizeY];
|
||
int ix,iy;
|
||
CSceneManager::m_cRenderSector=0;
|
||
|
||
vector3 vecMinBox,vecMaxBox;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMinBox.y;
|
||
vecMaxBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMaxBox.y;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
//if(m_SectorScene[ix+iy*m_LSizeX].isCulling())
|
||
if( CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumTop,-CSceneManager::GetCamera()->m_vecFrustumNormal[0],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumBottom,-CSceneManager::GetCamera()->m_vecFrustumNormal[1],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumLeft,-CSceneManager::GetCamera()->m_vecFrustumNormal[2],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumRight,-CSceneManager::GetCamera()->m_vecFrustumNormal[3],vecMaxBox,vecMinBox) < 0.0f)
|
||
{
|
||
if(m_SectorScene[ix+iy*m_LSizeX].m_MapWater && m_SectorScene[ix+iy*m_LSizeX].m_MapWater->m_bWaterRelection)
|
||
WaterHeightList.AddUnique(m_SectorScene[ix+iy*m_LSizeX].m_MapWater->m_fWaterHeight);
|
||
|
||
IsCulling[ix+iy*m_LSizeX]=true;
|
||
CSceneManager::m_cRenderSector++;
|
||
}
|
||
else
|
||
{
|
||
IsCulling[ix+iy*m_LSizeX]=true;
|
||
CSceneManager::m_cRenderSector++;
|
||
|
||
}
|
||
}
|
||
}
|
||
int nDetailSector=0;
|
||
int DetailSectorRender[9]={0,};
|
||
|
||
vector3 *vecViewPos=CSceneManager::GetCamera()->GetPosition();
|
||
|
||
//pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
//pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_TerrainLight);
|
||
|
||
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
pd3dDevice->LightEnable(1,FALSE);
|
||
pd3dDevice->LightEnable(2,FALSE);
|
||
pd3dDevice->LightEnable(3,FALSE);
|
||
pd3dDevice->LightEnable(4,FALSE);
|
||
pd3dDevice->LightEnable(5,FALSE);
|
||
pd3dDevice->LightEnable(6,FALSE);
|
||
pd3dDevice->LightEnable(7,FALSE);
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
color TerrainColor;
|
||
TerrainColor.a=0xff;
|
||
TerrainColor.r=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.r*255;
|
||
TerrainColor.g=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.g*255;
|
||
TerrainColor.b=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.b*255;
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,TerrainColor.c);
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterTerrainColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
//pd3dDevice->SetTexture(1,NULL);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
|
||
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
pd3dDevice->SetTransform(D3DTS_WORLD,(D3DMATRIX*)(&m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM));
|
||
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
|
||
if( vecMinBox.x <= vecViewPos->x && vecMaxBox.x >= vecViewPos->x &&
|
||
vecMinBox.z <= vecViewPos->z && vecMaxBox.z >= vecViewPos->z )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderDetail(pd3dDevice);
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.z-vecViewPos->z) <= SECTORSIZE/3.0f || fabsf(vecMaxBox.z-vecViewPos->z) <= SECTORSIZE/3.0f ) &&
|
||
vecMinBox.x <= vecViewPos->x && vecMaxBox.x >= vecViewPos->x )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderDetail(pd3dDevice);
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.x-vecViewPos->x) <= SECTORSIZE/3.0f || fabsf(vecMaxBox.x-vecViewPos->x) <= SECTORSIZE/3.0f ) &&
|
||
vecMinBox.z <= vecViewPos->z && vecMaxBox.z >= vecViewPos->z )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderDetail(pd3dDevice);
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.x-vecViewPos->x) <= SECTORSIZE/3.0f ||
|
||
fabsf(vecMaxBox.x-vecViewPos->x) <= SECTORSIZE/3.0f ) &&
|
||
(fabsf(vecMinBox.z-vecViewPos->z) <= SECTORSIZE/3.0f ||
|
||
fabsf(vecMaxBox.z-vecViewPos->z) <= SECTORSIZE/3.0f ) )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderDetail(pd3dDevice);
|
||
continue;
|
||
}
|
||
m_SectorScene[ix+iy*m_LSizeX].Render(pd3dDevice);
|
||
|
||
}
|
||
}
|
||
}
|
||
//*/
|
||
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
|
||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> world effect <20><> <20><><EFBFBD><EFBFBD> render
|
||
RenderMapEffect();
|
||
|
||
// Sector Light Render
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderSectorLight();
|
||
}
|
||
}
|
||
}
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TFACTOR );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
|
||
|
||
///*
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAREF, 0xee );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
//*/
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
|
||
matrix matIndent;
|
||
matIndent.MakeIdent();
|
||
|
||
pd3dDevice->SetTransform(D3DTS_TEXTURE1,(D3DMATRIX*)&matIndent);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(m_bHouseCulling) {
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderHouseObject(pd3dDevice);
|
||
}
|
||
else
|
||
m_SectorScene[ix+iy * m_LSizeX].RenderNotCullHouseObject(pd3dDevice);
|
||
|
||
}
|
||
else { // Culling Off 03.03.04 (arena <20><> <20><><EFBFBD><EFBFBD>)
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderHouseObject(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
|
||
D3DMATERIAL8 mtrl;
|
||
ZeroMemory( &mtrl, sizeof(D3DMATERIAL8) );
|
||
mtrl.Diffuse.r = mtrl.Ambient.r = 1.0f;
|
||
mtrl.Diffuse.g = mtrl.Ambient.g = 1.0f;
|
||
mtrl.Diffuse.b = mtrl.Ambient.b = 1.0f;
|
||
mtrl.Diffuse.a = mtrl.Ambient.a = 1.0f;
|
||
pd3dDevice->SetMaterial( &mtrl );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
|
||
if(BaseGraphicsLayer::m_VoodooOption)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAREF, 0xee );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
for(int cLight=1;cLight<8;cLight++)
|
||
{
|
||
pd3dDevice->LightEnable(cLight,FALSE);
|
||
}
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(m_bObjectCulling) { // 03.03.04 <20>Ʒ<EFBFBD><C6B7><EFBFBD>
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderObject(pd3dDevice);
|
||
}
|
||
}
|
||
else {
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderObject(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 2 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 3, D3DTSS_TEXCOORDINDEX, 3 );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
|
||
|
||
if(CRenderOption::m_bWaterBump) {
|
||
bool bUpdate = false;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_MapWater)
|
||
{
|
||
bUpdate = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if(bUpdate == true)
|
||
break;
|
||
}
|
||
|
||
|
||
static DWORD ftime = timeGetTime();
|
||
DWORD fFtime = timeGetTime();
|
||
|
||
if(((fFtime - ftime) > 30) && (bUpdate == true)) {
|
||
CWaterScene::m_pWaterTexGenerator->Update();
|
||
ftime = fFtime;
|
||
}
|
||
}
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_MapWater)
|
||
{
|
||
|
||
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_MapWater->m_bWaterRelection )
|
||
m_SectorScene[ix+iy*m_LSizeX].m_WaterScene.DeterminWaterTexture(pd3dDevice,true);
|
||
else
|
||
m_SectorScene[ix+iy*m_LSizeX].m_WaterScene.DeterminWaterTexture(pd3dDevice,false);
|
||
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderWater(pd3dDevice,false);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderGrass(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
//CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
if(BaseGraphicsLayer::m_VoodooOption)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,TRUE);
|
||
|
||
//Sector Sorting
|
||
|
||
D3DXMATRIX matView;
|
||
|
||
matrix *pmatView = CSceneManager::m_ViewCamera->GetMatPosition();
|
||
|
||
pd3dDevice->GetTransform(D3DTS_VIEW,&matView);
|
||
|
||
int Uindexx=(int)((pmatView->_41)/SECTORSIZE);
|
||
int Uindexy=(int)((pmatView->_43)/SECTORSIZE);
|
||
int Sindexx,Sindexy;
|
||
|
||
int iCurrentSector = 0;
|
||
|
||
m_iSortsNum = 0;
|
||
|
||
D3DXVECTOR4 vecViewSectorPos;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
//D3DXVECTOR3 vecSectorTmPos = D3DXVECTOR3(m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41,pmatView->_42,m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43);
|
||
D3DXVECTOR3 vecSectorTmPos = D3DXVECTOR3(m_SectorScene[ix+iy*m_LSizeX].m_TM._41,pmatView->_42,m_SectorScene[ix+iy*m_LSizeX].m_TM._43);
|
||
|
||
|
||
D3DXVec3Transform(&vecViewSectorPos,&vecSectorTmPos,&matView);
|
||
|
||
m_pSectorSorts[m_iSortsNum].fViewDist = vecViewSectorPos.z;
|
||
m_pSectorSorts[m_iSortsNum++].iSectorIndex = (ix+iy*m_LSizeX);
|
||
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
qsort((void *)m_pSectorSorts,(size_t)m_iSortsNum, sizeof(SectorSortNode_t),Sector_tCompare);
|
||
|
||
for(int iSortSector = 0;iSortSector < m_iSortsNum;iSortSector++ )
|
||
{
|
||
CSectorScene *pSort = &(m_SectorScene[m_pSectorSorts[iSortSector].iSectorIndex]);
|
||
|
||
Sindexx=(int)(pSort->m_TM._41/SECTORSIZE);
|
||
Sindexy=(int)(pSort->m_TM._43/SECTORSIZE);
|
||
|
||
if(!((Uindexx == Sindexx) && (Uindexy == Sindexy))) {
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
pSort->RenderPlant(pd3dDevice);
|
||
}
|
||
else {
|
||
iCurrentSector = m_pSectorSorts[iSortSector].iSectorIndex;
|
||
}
|
||
|
||
}
|
||
// <20><><EFBFBD><EFBFBD> current Sector <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Renderring
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
m_SectorScene[iCurrentSector].RenderPlant(pd3dDevice);
|
||
|
||
|
||
/* for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderPlant(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
pd3dDevice->LightEnable(1,FALSE);
|
||
pd3dDevice->LightEnable(2,FALSE);
|
||
pd3dDevice->LightEnable(3,FALSE);
|
||
pd3dDevice->LightEnable(4,FALSE);
|
||
pd3dDevice->LightEnable(5,FALSE);
|
||
pd3dDevice->LightEnable(6,FALSE);
|
||
pd3dDevice->LightEnable(7,FALSE);
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
// 08.27 <20><><EFBFBD><EFBFBD>
|
||
/*CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterFurGrassColor.c);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
|
||
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderGrass(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
//CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
|
||
/*
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
*/
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
/*** for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderFall(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
***/
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_TEXCOORDINDEX,0);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_TEXCOORDINDEX,1);
|
||
|
||
//CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_PASSTHRU);
|
||
//CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
|
||
|
||
//CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_PASSTHRU);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
pd3dDevice->SetTransform(D3DTS_WORLD,(D3DMATRIX*)(&m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM));
|
||
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
|
||
if( vecMinBox.x <= vecViewPos->x && vecMaxBox.x >= vecViewPos->x &&
|
||
vecMinBox.z <= vecViewPos->z && vecMaxBox.z >= vecViewPos->z )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderLandscapeEffect(pd3dDevice);
|
||
//m_SectorScene[ix+iy*m_LSizeX].UpdateLandscapeEffect();
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.z-vecViewPos->z) <= SECTORSIZE/2.0f || fabsf(vecMaxBox.z-vecViewPos->z) <= SECTORSIZE/2.0f ) &&
|
||
vecMinBox.x <= vecViewPos->x && vecMaxBox.x >= vecViewPos->x )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderLandscapeEffect(pd3dDevice);
|
||
//m_SectorScene[ix+iy*m_LSizeX].UpdateLandscapeEffect();
|
||
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.x-vecViewPos->x) <= SECTORSIZE/2.0f || fabsf(vecMaxBox.x-vecViewPos->x) <= SECTORSIZE/2.0f ) &&
|
||
vecMinBox.z <= vecViewPos->z && vecMaxBox.z >= vecViewPos->z )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderLandscapeEffect(pd3dDevice);
|
||
//m_SectorScene[ix+iy*m_LSizeX].UpdateLandscapeEffect();
|
||
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.x-vecViewPos->x) <= SECTORSIZE/2.0f ||
|
||
fabsf(vecMaxBox.x-vecViewPos->x) <= SECTORSIZE/2.0f ) &&
|
||
(fabsf(vecMinBox.z-vecViewPos->z) <= SECTORSIZE/2.0f ||
|
||
fabsf(vecMaxBox.z-vecViewPos->z) <= SECTORSIZE/2.0f ) )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderLandscapeEffect(pd3dDevice);
|
||
//m_SectorScene[ix+iy*m_LSizeX].UpdateLandscapeEffect();
|
||
|
||
continue;
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
delete [] IsCulling;
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_FOGENABLE,TRUE);
|
||
}
|
||
void CHeightFieldScene::Render(LPDIRECT3DDEVICE8 pd3dDevice)
|
||
{
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
|
||
if(CSceneManager::m_pBspScene)
|
||
{
|
||
pd3dDevice->SetTransform(D3DTS_WORLD,CSceneManager::m_pBspScene->m_AccumulateTM);
|
||
|
||
matrix matHousePos;
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,matHousePos);
|
||
|
||
matrix *matViewPosition=CSceneManager::GetCamera()->GetMatPosition();
|
||
|
||
matrix matViewPos;
|
||
vector3 vecViewPos=matViewPosition->GetLoc();
|
||
matViewPos.Translation(vecViewPos);
|
||
|
||
matrix matInvTM,matPos;
|
||
matInvTM.Inverse(matHousePos);
|
||
|
||
matPos=matViewPos*matInvTM;
|
||
|
||
CSceneManager::m_pBspScene->m_HouseObject->m_pBspObject->Render(pd3dDevice,matPos.GetLoc());
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
if(CSceneManager::m_pBspScene->m_HouseObject->m_pBspObject->m_bSkyRender==false)
|
||
return;
|
||
//CSceneManager::m_pBspScene->Render(pd3dDevice);
|
||
}
|
||
// WaterReflection Count
|
||
List<float> WaterHeightList;
|
||
int cDrawTerr=0;
|
||
//bool IsCulling[LSIZEX*LSIZEY];
|
||
bool *IsCulling=new bool[m_LSizeX*m_LSizeY];
|
||
int ix,iy;
|
||
CSceneManager::m_cRenderSector=0;
|
||
|
||
vector3 vecMinBox,vecMaxBox;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMinBox.y;
|
||
vecMaxBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMaxBox.y;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
//if(m_SectorScene[ix+iy*m_LSizeX].isCulling())
|
||
if( CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumTop,-CSceneManager::GetCamera()->m_vecFrustumNormal[0],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumBottom,-CSceneManager::GetCamera()->m_vecFrustumNormal[1],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumLeft,-CSceneManager::GetCamera()->m_vecFrustumNormal[2],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumRight,-CSceneManager::GetCamera()->m_vecFrustumNormal[3],vecMaxBox,vecMinBox) < 0.0f)
|
||
{
|
||
if(m_SectorScene[ix+iy*m_LSizeX].m_MapWater && m_SectorScene[ix+iy*m_LSizeX].m_MapWater->m_bWaterRelection)
|
||
WaterHeightList.AddUnique(m_SectorScene[ix+iy*m_LSizeX].m_MapWater->m_fWaterHeight);
|
||
|
||
IsCulling[ix+iy*m_LSizeX]=true;
|
||
CSceneManager::m_cRenderSector++;
|
||
}
|
||
else
|
||
{
|
||
IsCulling[ix+iy*m_LSizeX]=false;
|
||
}
|
||
}
|
||
}
|
||
int nDetailSector=0;
|
||
int DetailSectorRender[9]={0,};
|
||
|
||
vector3 *vecViewPos=CSceneManager::GetCamera()->GetPosition();
|
||
|
||
//pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
//pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_TerrainLight);
|
||
|
||
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
pd3dDevice->LightEnable(1,FALSE);
|
||
pd3dDevice->LightEnable(2,FALSE);
|
||
pd3dDevice->LightEnable(3,FALSE);
|
||
pd3dDevice->LightEnable(4,FALSE);
|
||
pd3dDevice->LightEnable(5,FALSE);
|
||
pd3dDevice->LightEnable(6,FALSE);
|
||
pd3dDevice->LightEnable(7,FALSE);
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
color TerrainColor;
|
||
TerrainColor.a=0xff;
|
||
TerrainColor.r=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.r*255;
|
||
TerrainColor.g=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.g*255;
|
||
TerrainColor.b=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.b*255;
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,TerrainColor.c);
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterTerrainColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
//pd3dDevice->SetTexture(1,NULL);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,TRUE);
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
pd3dDevice->SetTransform(D3DTS_WORLD,(D3DMATRIX*)(&m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM));
|
||
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
|
||
if( vecMinBox.x <= vecViewPos->x && vecMaxBox.x >= vecViewPos->x &&
|
||
vecMinBox.z <= vecViewPos->z && vecMaxBox.z >= vecViewPos->z )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderDetail(pd3dDevice);
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.z-vecViewPos->z) <= SECTORSIZE/3.0f || fabsf(vecMaxBox.z-vecViewPos->z) <= SECTORSIZE/3.0f ) &&
|
||
vecMinBox.x <= vecViewPos->x && vecMaxBox.x >= vecViewPos->x )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderDetail(pd3dDevice);
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.x-vecViewPos->x) <= SECTORSIZE/3.0f || fabsf(vecMaxBox.x-vecViewPos->x) <= SECTORSIZE/3.0f ) &&
|
||
vecMinBox.z <= vecViewPos->z && vecMaxBox.z >= vecViewPos->z )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderDetail(pd3dDevice);
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.x-vecViewPos->x) <= SECTORSIZE/3.0f ||
|
||
fabsf(vecMaxBox.x-vecViewPos->x) <= SECTORSIZE/3.0f ) &&
|
||
(fabsf(vecMinBox.z-vecViewPos->z) <= SECTORSIZE/3.0f ||
|
||
fabsf(vecMaxBox.z-vecViewPos->z) <= SECTORSIZE/3.0f ) )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderDetail(pd3dDevice);
|
||
continue;
|
||
}
|
||
m_SectorScene[ix+iy*m_LSizeX].Render(pd3dDevice);
|
||
|
||
}
|
||
}
|
||
}
|
||
//*/
|
||
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
|
||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> world effect <20><> <20><><EFBFBD><EFBFBD> render
|
||
RenderMapEffect();
|
||
|
||
// Sector Light Render
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderSectorLight();
|
||
}
|
||
}
|
||
}
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TFACTOR );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
|
||
|
||
///*
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAREF, 0xee );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
//*/
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
|
||
matrix matIndent;
|
||
matIndent.MakeIdent();
|
||
|
||
pd3dDevice->SetTransform(D3DTS_TEXTURE1,(D3DMATRIX*)&matIndent);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(m_bHouseCulling) {
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderHouseObject(pd3dDevice);
|
||
}
|
||
else
|
||
m_SectorScene[ix+iy * m_LSizeX].RenderNotCullHouseObject(pd3dDevice);
|
||
|
||
}
|
||
else { // Culling Off 03.03.04 (arena <20><> <20><><EFBFBD><EFBFBD>)
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderHouseObject(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
|
||
D3DMATERIAL8 mtrl;
|
||
ZeroMemory( &mtrl, sizeof(D3DMATERIAL8) );
|
||
mtrl.Diffuse.r = mtrl.Ambient.r = 1.0f;
|
||
mtrl.Diffuse.g = mtrl.Ambient.g = 1.0f;
|
||
mtrl.Diffuse.b = mtrl.Ambient.b = 1.0f;
|
||
mtrl.Diffuse.a = mtrl.Ambient.a = 1.0f;
|
||
pd3dDevice->SetMaterial( &mtrl );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
|
||
if(BaseGraphicsLayer::m_VoodooOption)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAREF, 0xee );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
for(int cLight=1;cLight<8;cLight++)
|
||
{
|
||
pd3dDevice->LightEnable(cLight,FALSE);
|
||
}
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(m_bObjectCulling) { // 03.03.04 <20>Ʒ<EFBFBD><C6B7><EFBFBD>
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderObject(pd3dDevice);
|
||
}
|
||
}
|
||
else {
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderObject(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
|
||
CSceneManager::m_CharacterManager.Render(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 2 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 3, D3DTSS_TEXCOORDINDEX, 3 );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
|
||
|
||
if(CRenderOption::m_bWaterBump) {
|
||
bool bUpdate = false;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_MapWater)
|
||
{
|
||
bUpdate = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if(bUpdate == true)
|
||
break;
|
||
}
|
||
|
||
|
||
static DWORD ftime = timeGetTime();
|
||
DWORD fFtime = timeGetTime();
|
||
|
||
if(((fFtime - ftime) > 30) && (bUpdate == true)) {
|
||
CWaterScene::m_pWaterTexGenerator->Update();
|
||
ftime = fFtime;
|
||
}
|
||
}
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_MapWater)
|
||
{
|
||
|
||
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_MapWater->m_bWaterRelection )
|
||
m_SectorScene[ix+iy*m_LSizeX].m_WaterScene.DeterminWaterTexture(pd3dDevice,true);
|
||
else
|
||
m_SectorScene[ix+iy*m_LSizeX].m_WaterScene.DeterminWaterTexture(pd3dDevice,false);
|
||
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderWater(pd3dDevice,false);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderGrass(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
//CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
if(BaseGraphicsLayer::m_VoodooOption)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,TRUE);
|
||
|
||
//Sector Sorting
|
||
|
||
D3DXMATRIX matView;
|
||
|
||
matrix *pmatView = CSceneManager::m_ViewCamera->GetMatPosition();
|
||
|
||
pd3dDevice->GetTransform(D3DTS_VIEW,&matView);
|
||
|
||
int Uindexx=(int)((pmatView->_41)/SECTORSIZE);
|
||
int Uindexy=(int)((pmatView->_43)/SECTORSIZE);
|
||
int Sindexx,Sindexy;
|
||
|
||
int iCurrentSector = 0;
|
||
|
||
m_iSortsNum = 0;
|
||
|
||
D3DXVECTOR4 vecViewSectorPos;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
//D3DXVECTOR3 vecSectorTmPos = D3DXVECTOR3(m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41,pmatView->_42,m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43);
|
||
D3DXVECTOR3 vecSectorTmPos = D3DXVECTOR3(m_SectorScene[ix+iy*m_LSizeX].m_TM._41,pmatView->_42,m_SectorScene[ix+iy*m_LSizeX].m_TM._43);
|
||
|
||
|
||
D3DXVec3Transform(&vecViewSectorPos,&vecSectorTmPos,&matView);
|
||
|
||
m_pSectorSorts[m_iSortsNum].fViewDist = vecViewSectorPos.z;
|
||
m_pSectorSorts[m_iSortsNum++].iSectorIndex = (ix+iy*m_LSizeX);
|
||
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
qsort((void *)m_pSectorSorts,(size_t)m_iSortsNum, sizeof(SectorSortNode_t),Sector_tCompare);
|
||
|
||
for(int iSortSector = 0;iSortSector < m_iSortsNum;iSortSector++ )
|
||
{
|
||
CSectorScene *pSort = &(m_SectorScene[m_pSectorSorts[iSortSector].iSectorIndex]);
|
||
|
||
Sindexx=(int)(pSort->m_TM._41/SECTORSIZE);
|
||
Sindexy=(int)(pSort->m_TM._43/SECTORSIZE);
|
||
|
||
if(!((Uindexx == Sindexx) && (Uindexy == Sindexy))) {
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
pSort->RenderPlant(pd3dDevice);
|
||
}
|
||
else {
|
||
iCurrentSector = m_pSectorSorts[iSortSector].iSectorIndex;
|
||
}
|
||
|
||
}
|
||
// <20><><EFBFBD><EFBFBD> current Sector <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Renderring
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
m_SectorScene[iCurrentSector].RenderPlant(pd3dDevice);
|
||
|
||
|
||
/* for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderPlant(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
pd3dDevice->LightEnable(1,FALSE);
|
||
pd3dDevice->LightEnable(2,FALSE);
|
||
pd3dDevice->LightEnable(3,FALSE);
|
||
pd3dDevice->LightEnable(4,FALSE);
|
||
pd3dDevice->LightEnable(5,FALSE);
|
||
pd3dDevice->LightEnable(6,FALSE);
|
||
pd3dDevice->LightEnable(7,FALSE);
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
// 08.27 <20><><EFBFBD><EFBFBD>
|
||
/*CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterFurGrassColor.c);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
|
||
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderGrass(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
//CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
|
||
/*
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
*/
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
/*** for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderFall(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
***/
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_TEXCOORDINDEX,0);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_TEXCOORDINDEX,1);
|
||
|
||
//CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_PASSTHRU);
|
||
//CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
|
||
|
||
//CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_PASSTHRU);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
pd3dDevice->SetTransform(D3DTS_WORLD,(D3DMATRIX*)(&m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM));
|
||
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
|
||
if( vecMinBox.x <= vecViewPos->x && vecMaxBox.x >= vecViewPos->x &&
|
||
vecMinBox.z <= vecViewPos->z && vecMaxBox.z >= vecViewPos->z )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderLandscapeEffect(pd3dDevice);
|
||
//m_SectorScene[ix+iy*m_LSizeX].UpdateLandscapeEffect();
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.z-vecViewPos->z) <= SECTORSIZE/2.0f || fabsf(vecMaxBox.z-vecViewPos->z) <= SECTORSIZE/2.0f ) &&
|
||
vecMinBox.x <= vecViewPos->x && vecMaxBox.x >= vecViewPos->x )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderLandscapeEffect(pd3dDevice);
|
||
//m_SectorScene[ix+iy*m_LSizeX].UpdateLandscapeEffect();
|
||
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.x-vecViewPos->x) <= SECTORSIZE/2.0f || fabsf(vecMaxBox.x-vecViewPos->x) <= SECTORSIZE/2.0f ) &&
|
||
vecMinBox.z <= vecViewPos->z && vecMaxBox.z >= vecViewPos->z )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderLandscapeEffect(pd3dDevice);
|
||
//m_SectorScene[ix+iy*m_LSizeX].UpdateLandscapeEffect();
|
||
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.x-vecViewPos->x) <= SECTORSIZE/2.0f ||
|
||
fabsf(vecMaxBox.x-vecViewPos->x) <= SECTORSIZE/2.0f ) &&
|
||
(fabsf(vecMinBox.z-vecViewPos->z) <= SECTORSIZE/2.0f ||
|
||
fabsf(vecMaxBox.z-vecViewPos->z) <= SECTORSIZE/2.0f ) )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderLandscapeEffect(pd3dDevice);
|
||
//m_SectorScene[ix+iy*m_LSizeX].UpdateLandscapeEffect();
|
||
|
||
continue;
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
delete [] IsCulling;
|
||
}
|
||
void CHeightFieldScene::RenderMapEffect() {
|
||
|
||
bool *IsCulling=new bool[m_LSizeX*m_LSizeY];
|
||
int ix,iy;
|
||
CSceneManager::m_cRenderSector=0;
|
||
|
||
vector3 vecMinBox,vecMaxBox;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMinBox.y;
|
||
vecMaxBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMaxBox.y;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
//if(m_SectorScene[ix+iy*m_LSizeX].isCulling())
|
||
if( CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumTop,-CSceneManager::GetCamera()->m_vecFrustumNormal[0],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumBottom,-CSceneManager::GetCamera()->m_vecFrustumNormal[1],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumLeft,-CSceneManager::GetCamera()->m_vecFrustumNormal[2],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumRight,-CSceneManager::GetCamera()->m_vecFrustumNormal[3],vecMaxBox,vecMinBox) < 0.0f)
|
||
{
|
||
|
||
IsCulling[ix+iy*m_LSizeX]=true;
|
||
CSceneManager::m_cRenderSector++;
|
||
}
|
||
else
|
||
{
|
||
IsCulling[ix+iy*m_LSizeX]=false;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//Effect
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(m_bEffectCulling) { // Culling <20><><EFBFBD><EFBFBD> 03.03.04
|
||
//if(IsCulling[ix+iy*m_LSizeX])
|
||
//{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderEffect(IsCulling[ix+iy*m_LSizeX]);
|
||
//}
|
||
|
||
}
|
||
else { // Culling <20><><EFBFBD><EFBFBD> 03.03.04
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderEffect();
|
||
}
|
||
}
|
||
}
|
||
delete[] IsCulling;
|
||
|
||
}
|
||
void CHeightFieldScene::Tessellate()
|
||
{
|
||
m_SectorScene->m_NextTriNode=0;
|
||
CSectorScene *Patch;
|
||
int ix,iy;
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
Patch=m_QuadSector[ix+iy*m_LSizeY];
|
||
Patch->Reset();
|
||
|
||
if(ix>0)
|
||
Patch->m_BaseLeft.LeftNeighbor=&m_QuadSector[(ix-1)+iy*m_LSizeX]->m_BaseRight;
|
||
else
|
||
Patch->m_BaseLeft.LeftNeighbor=NULL;
|
||
if(ix<m_LSizeX-1)
|
||
Patch->m_BaseRight.LeftNeighbor=&m_QuadSector[(ix+1)+iy*m_LSizeX]->m_BaseLeft;
|
||
else
|
||
Patch->m_BaseRight.LeftNeighbor=NULL;
|
||
|
||
if(iy>0)
|
||
Patch->m_BaseLeft.RightNeighbor=&m_QuadSector[ix+(iy-1)*m_LSizeX]->m_BaseRight;
|
||
else
|
||
Patch->m_BaseLeft.RightNeighbor=NULL;
|
||
if(iy<m_LSizeY-1)
|
||
Patch->m_BaseRight.RightNeighbor=&m_QuadSector[ix+(iy+1)*m_LSizeX]->m_BaseLeft;
|
||
else
|
||
Patch->m_BaseRight.RightNeighbor=NULL;
|
||
}
|
||
}
|
||
|
||
for(int i=0;i<m_LSizeX*m_LSizeY;i++)
|
||
m_SectorScene[i].Tessellate();
|
||
|
||
for(i=0;i<m_LSizeX*m_LSizeY;i++)
|
||
m_SectorScene[i].PrepareRender();
|
||
}
|
||
|
||
bool CHeightFieldScene::CheckingTessellate()
|
||
{
|
||
|
||
vector3 *ViewPos;
|
||
vector3 CharPos;
|
||
if(CSceneManager::m_ViewerMode==0 || CSceneManager::m_ViewerMode==2)
|
||
ViewPos=CSceneManager::GetCamera()->GetPosition();
|
||
else
|
||
{
|
||
//CSceneManager::m_CharacterList[0]->GetPosition(CharPos.x,CharPos.y,CharPos.z);
|
||
if( CSceneManager::m_CharacterManager.m_CharacterList.num == 0 )
|
||
{
|
||
ViewPos=CSceneManager::GetCamera()->GetPosition();
|
||
}
|
||
else
|
||
{
|
||
CSceneManager::m_CharacterManager.m_CharacterList[0].m_pChrmodel->GetPosition(CharPos.x,CharPos.y,CharPos.z);
|
||
ViewPos=&CharPos;
|
||
}
|
||
}
|
||
|
||
//vector3 *ViewPos=CSceneManager::GetCamera()->GetPosition();
|
||
if( m_NowTessellatePosX == (int)(ViewPos->x/(SECTORSIZE/FIELDDIVIDE)) &&
|
||
m_NowTessellatePosY == (int)(ViewPos->z/(SECTORSIZE/FIELDDIVIDE)))
|
||
return false;
|
||
Tessellate();
|
||
m_NowTessellatePosX=(int)(ViewPos->x/(SECTORSIZE/FIELDDIVIDE));
|
||
m_NowTessellatePosY=(int)(ViewPos->z/(SECTORSIZE/FIELDDIVIDE));
|
||
m_GrassSceneManager.UpdateRange();
|
||
|
||
return true;
|
||
}
|
||
|
||
/*
|
||
matrix *matViewPosition=(matrix*)CSceneManager::GetCamera()->GetMatPosition();
|
||
matrix *matView=(matrix*)CSceneManager::GetCamera()->GetMatView();
|
||
matrix matFront;
|
||
matFront.Translation(vector3(0.0f,0.0f,1.0f));
|
||
matFront=matFront*(*matViewPosition);
|
||
vector3 vecRelectionDir;
|
||
vector3 vecViewPos=matViewPosition->GetLoc();
|
||
vecRelectionDir=matFront.GetLoc()-vecViewPos;
|
||
vecRelectionDir.y=-vecRelectionDir.y;
|
||
//vecRelectionDir.y-=(2.0f*(vecRelectionDir.y-vecViewPos.y));
|
||
//vecViewPos.y=-vecViewPos.y;
|
||
//vecViewPos.y+=3000.0f*2.0f;
|
||
vector3 vecUp;
|
||
vecUp.x=matView->_12;
|
||
vecUp.y=-1.0f;//matView->_22;
|
||
vecUp.z=matView->_32;
|
||
vecUp.Normalize();
|
||
/*
|
||
vecRelectionDir.x=matView->_13;
|
||
vecRelectionDir.y=matView->_23;
|
||
vecRelectionDir.z=matView->_33;
|
||
|
||
/*
|
||
vecRelectionDir.x=matView->_13;
|
||
vecRelectionDir.y=1.0f;
|
||
vecRelectionDir.z=matView->_33;
|
||
//
|
||
vecRelectionDir.x=0.0f;
|
||
vecRelectionDir.y=1.0f;
|
||
vecRelectionDir.z=0.0f;
|
||
vecRelectionDir.Normalize();
|
||
//matRelectionView.CameraLookAt(vecViewPos,vecRelectionDir,vecUp);
|
||
//matRelectionView.CameraLookAt(vecViewPos,vecRelectionDir,vecUp);
|
||
//pd3dDevice->SetTransform(D3DTS_VIEW,(D3DMATRIX*)&matRelectionView);
|
||
|
||
matFront.MakeIdent();
|
||
matFront._22=-1.0f;
|
||
|
||
matrix temp;
|
||
*/
|
||
|
||
|
||
float CHeightFieldScene::GetHeight(vector3 vecPos)
|
||
{
|
||
int ix,iy;
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41 <= vecPos.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41+SECTORSIZE > vecPos.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43 <= vecPos.z &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43+SECTORSIZE > vecPos.z)
|
||
{
|
||
return m_SectorScene[ix+iy*m_LSizeX].GetHeight(vecPos);
|
||
}
|
||
}
|
||
}
|
||
return 0.0f;
|
||
}
|
||
|
||
void CHeightFieldScene::GetHeightFieldShadowPoly(vector3 vecPos,List<vector3> &vecPolyList)
|
||
{
|
||
int ix,iy;
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41 <= vecPos.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41+SECTORSIZE > vecPos.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43 <= vecPos.z &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43+SECTORSIZE > vecPos.z)
|
||
{
|
||
//m_SectorScene[ix+iy*LSIZEX].GetShadowPoly(vecPos,vecPolyList);
|
||
m_SectorScene[ix+iy*m_LSizeX].GetHeightFieldShadowPoly(vecPos,vecPolyList);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CHeightFieldScene::GetLight(vector3 vecPos,List<D3DLIGHT8> &LightList)
|
||
{
|
||
int ix,iy;
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41 <= vecPos.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41+SECTORSIZE > vecPos.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43 <= vecPos.z &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43+SECTORSIZE > vecPos.z)
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].GetLight(vecPos,LightList);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CHeightFieldScene::GetInHouseShadowPoly(vector3 vecPos,List<vector3> &vecPolyList,vector3 vecLightPos)
|
||
{
|
||
int ix,iy;
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41 <= vecPos.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41+SECTORSIZE > vecPos.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43 <= vecPos.z &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43+SECTORSIZE > vecPos.z)
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].GetInHouseShadowPoly(vecPos,vecPolyList,vecLightPos);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CHeightFieldScene::GetLineIntersectPoly(vector3 vecStart, vector3 vecEnd,List<vector3> &vecPolyList)
|
||
{
|
||
int ix,iy;
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41 <= vecStart.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41+SECTORSIZE > vecStart.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43 <= vecStart.z &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43+SECTORSIZE > vecStart.z)
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].GetLineIntersectPoly(vecStart,vecEnd,vecPolyList);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CHeightFieldScene::AllObjectCalcLens()
|
||
{
|
||
int ix,iy;
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].AllObjectCalcLens();
|
||
}
|
||
}
|
||
}
|
||
|
||
void CHeightFieldScene::GetHeightFieldRangePoly(vector3 vecPos,List<vector3> &vecPolyList, float fRange)
|
||
{
|
||
int ix,iy;
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41 <= vecPos.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41+SECTORSIZE > vecPos.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43 <= vecPos.z &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43+SECTORSIZE > vecPos.z)
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].GetHeightFieldRangePoly(vecPos,vecPolyList,fRange);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
char* CHeightFieldScene::GetHeightFieldShadowCollision(vector3 vecPos)
|
||
{
|
||
int ix,iy;
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if( m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41 <= vecPos.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41+SECTORSIZE > vecPos.x &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43 <= vecPos.z &&
|
||
m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43+SECTORSIZE > vecPos.z)
|
||
{
|
||
if(m_SectorScene[ix+iy*m_LSizeX].m_ShadowUsed==-1)
|
||
return NULL;
|
||
|
||
return m_SectorScene[ix+iy*m_LSizeX].m_SectorShadowCollision[
|
||
m_SectorScene[ix+iy*m_LSizeX].m_ShadowUsed];
|
||
|
||
}
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
void CHeightFieldScene::Update(float fUpdate)
|
||
{
|
||
m_GrassSceneManager.Update(fUpdate/30.0f);
|
||
|
||
int ix,iy;
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].m_TreeObjectNode.Update(fUpdate/60.0f);
|
||
|
||
m_SectorScene[ix+iy*m_LSizeX].UpdateLandscapeEffect();
|
||
}
|
||
}
|
||
float fTime = CSceneManager::GetWeatherTime();
|
||
// ij<><C4B3><EFBFBD><EFBFBD> <20><>ġ
|
||
if((fTime > 19.0f || fTime < 6.0f) && ( CSceneManager::m_bCharacterLightOp))
|
||
{
|
||
CSceneManager::m_bCharacterLight = true;
|
||
}
|
||
else
|
||
CSceneManager::m_bCharacterLight = false;
|
||
|
||
vector3 vecMinBox,vecMaxBox;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMinBox.y;
|
||
vecMaxBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMaxBox.y;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
//if(m_SectorScene[ix+iy*m_LSizeX].isCulling())
|
||
if( CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumTop,-CSceneManager::GetCamera()->m_vecFrustumNormal[0],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumBottom,-CSceneManager::GetCamera()->m_vecFrustumNormal[1],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumLeft,-CSceneManager::GetCamera()->m_vecFrustumNormal[2],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumRight,-CSceneManager::GetCamera()->m_vecFrustumNormal[3],vecMaxBox,vecMinBox) < 0.0f)
|
||
{
|
||
if(fTime > 19.0f || fTime < 5.0f)
|
||
m_SectorScene[ix+iy*m_LSizeX].SettingNight(true);
|
||
else
|
||
m_SectorScene[ix+iy*m_LSizeX].SettingNight(false);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
}
|
||
|
||
|
||
void CHeightFieldScene::GenerateSectorSceneObjects( int sectorX, int sectorY )
|
||
{
|
||
for( int cSector = 0; cSector < GetLSizeX()*GetLSizeY(); cSector++ )
|
||
{
|
||
int sectorindexx = m_SectorScene[cSector].m_AccumulateTM._41/SECTORSIZE;
|
||
int sectorindexy = m_SectorScene[cSector].m_AccumulateTM._43/SECTORSIZE;
|
||
|
||
if( sectorX == sectorindexx && sectorY == sectorindexy )
|
||
m_SectorScene[cSector].GenerateObject();
|
||
}
|
||
}
|
||
|
||
void CHeightFieldScene::RenderShadow(LPDIRECT3DDEVICE8 pd3dDevice)
|
||
{
|
||
int ix,iy;
|
||
|
||
vector3 vecMinBox,vecMaxBox;
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMinBox.y;
|
||
vecMaxBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMaxBox.y;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
|
||
if( CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumTop,-CSceneManager::GetCamera()->m_vecFrustumNormal[0],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumBottom,-CSceneManager::GetCamera()->m_vecFrustumNormal[1],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumLeft,-CSceneManager::GetCamera()->m_vecFrustumNormal[2],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumRight,-CSceneManager::GetCamera()->m_vecFrustumNormal[3],vecMaxBox,vecMinBox) < 0.0f)
|
||
{
|
||
if(CRenderOption::m_ObjectProjectShadow)
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderObjectShadow(pd3dDevice);
|
||
pd3dDevice->SetTransform(D3DTS_WORLD,m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM);
|
||
if(CRenderOption::m_TreeProjectShadow)
|
||
m_SectorScene[ix+iy*m_LSizeX].m_TreeObjectNode.RenderShadow(pd3dDevice,CSectorScene::m_pShadowTexture);
|
||
|
||
}
|
||
}
|
||
}
|
||
//m_GrassSceneManager.RenderShadow(pd3dDevice,CSectorScene::m_pShadowTexture);
|
||
}
|
||
|
||
int CHeightFieldScene::AddShadowPoly(vector3 vecPos,int nMethod)
|
||
{
|
||
static int nID=0;
|
||
CShadowedPoly AddNode;
|
||
AddNode.m_vecShadowPos=vecPos;
|
||
AddNode.m_nGatherMethod=nMethod;
|
||
AddNode.m_nShadowID=nID;
|
||
AddNode.m_bActive=true;
|
||
m_ShadowedVertexList.Add(AddNode);
|
||
nID++;
|
||
return nID-1;
|
||
}
|
||
|
||
CHeightFieldScene::CShadowedPoly* CHeightFieldScene::GetShadowPolyList(int nID)
|
||
{
|
||
for(int i=0;i<m_ShadowedVertexList.num;i++)
|
||
{
|
||
if(m_ShadowedVertexList[i].m_nShadowID==nID)
|
||
{
|
||
return &m_ShadowedVertexList[i];
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
void CHeightFieldScene::DeleteShadowPolyList(int nID)
|
||
{
|
||
for(int i=0;i<m_ShadowedVertexList.num;i++)
|
||
{
|
||
if(m_ShadowedVertexList[i].m_nShadowID==nID)
|
||
{
|
||
m_ShadowedVertexList.DelIndex(i);
|
||
return;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
void CHeightFieldScene::RebuildShadowPoly()
|
||
{
|
||
for(int i=0;i<m_ShadowedVertexList.num;i++)
|
||
{
|
||
m_ShadowedVertexList[i].m_ShadowedPolyList.num=0;
|
||
|
||
if(m_ShadowedVertexList[i].m_nGatherMethod==0)
|
||
{
|
||
GetHeightFieldShadowPoly(m_ShadowedVertexList[i].m_vecShadowPos,
|
||
m_ShadowedVertexList[i].m_ShadowedPolyList);
|
||
}
|
||
else
|
||
{
|
||
GetHeightFieldRangePoly(m_ShadowedVertexList[i].m_vecShadowPos,
|
||
m_ShadowedVertexList[i].m_ShadowedPolyList,3000.0f);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CHeightFieldScene::RenderGlare(LPDIRECT3DDEVICE8 pd3dDevice)
|
||
{
|
||
bool *IsCulling=new bool[m_LSizeX*m_LSizeY];
|
||
int ix,iy;
|
||
CSceneManager::m_cRenderSector=0;
|
||
|
||
vector3 vecMinBox,vecMaxBox;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMinBox.y;
|
||
vecMaxBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMaxBox.y;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
//if(m_SectorScene[ix+iy*m_LSizeX].isCulling())
|
||
if( CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumTop,-CSceneManager::GetCamera()->m_vecFrustumNormal[0],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumBottom,-CSceneManager::GetCamera()->m_vecFrustumNormal[1],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumLeft,-CSceneManager::GetCamera()->m_vecFrustumNormal[2],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumRight,-CSceneManager::GetCamera()->m_vecFrustumNormal[3],vecMaxBox,vecMinBox) < 0.0f)
|
||
{
|
||
IsCulling[ix+iy*m_LSizeX]=true;
|
||
}
|
||
else
|
||
{
|
||
IsCulling[ix+iy*m_LSizeX]=false;
|
||
}
|
||
}
|
||
}
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderGlare(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
delete [] IsCulling;
|
||
}
|
||
|
||
int Sector_tCompare(const void *arg1,const void *arg2) {
|
||
|
||
if(((SectorSortNode_t *)arg1)->fViewDist < ((SectorSortNode_t *)arg2)->fViewDist)
|
||
return 1;
|
||
else if(((SectorSortNode_t *)arg1)->fViewDist > ((SectorSortNode_t *)arg2)->fViewDist)
|
||
return -1;
|
||
return 0;
|
||
|
||
}
|
||
|
||
void CHeightFieldScene::Destroy(void)
|
||
{
|
||
for(int ix=0; ix < GetLSizeX(); ix++)
|
||
{
|
||
for(int iy = 0; iy < GetLSizeX(); iy++)
|
||
{
|
||
m_SectorScene[ix + iy * GetLSizeX()].UnloadAllData();
|
||
}
|
||
}
|
||
}
|
||
|
||
void CHeightFieldScene::RenderBlackField( LPDIRECT3DDEVICE8 pDevice )
|
||
{
|
||
pDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
if(CSceneManager::m_pBspScene)
|
||
{
|
||
pDevice->SetTransform(D3DTS_WORLD,CSceneManager::m_pBspScene->m_AccumulateTM);
|
||
|
||
matrix matHousePos;
|
||
pDevice->GetTransform(D3DTS_WORLD,matHousePos);
|
||
|
||
matrix *matViewPosition=CSceneManager::GetCamera()->GetMatPosition();
|
||
|
||
matrix matViewPos;
|
||
vector3 vecViewPos=matViewPosition->GetLoc();
|
||
matViewPos.Translation(vecViewPos);
|
||
|
||
matrix matInvTM,matPos;
|
||
matInvTM.Inverse(matHousePos);
|
||
|
||
matPos=matViewPos*matInvTM;
|
||
|
||
CSceneManager::m_pBspScene->m_HouseObject->m_pBspObject->Render(pDevice,matPos.GetLoc());
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
if(CSceneManager::m_pBspScene->m_HouseObject->m_pBspObject->m_bSkyRender==false)
|
||
return;
|
||
//CSceneManager::m_pBspScene->Render(pd3dDevice);
|
||
}
|
||
// WaterReflection Count
|
||
List<float> WaterHeightList;
|
||
int cDrawTerr=0;
|
||
//bool IsCulling[LSIZEX*LSIZEY];
|
||
bool *IsCulling=new bool[m_LSizeX*m_LSizeY];
|
||
int ix,iy;
|
||
CSceneManager::m_cRenderSector=0;
|
||
|
||
vector3 vecMinBox,vecMaxBox;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMinBox.y;
|
||
vecMaxBox.y=m_SectorScene[ix+iy*m_LSizeX].m_vecMaxBox.y;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
//if(m_SectorScene[ix+iy*m_LSizeX].isCulling())
|
||
if( CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumTop,-CSceneManager::GetCamera()->m_vecFrustumNormal[0],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumBottom,-CSceneManager::GetCamera()->m_vecFrustumNormal[1],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumLeft,-CSceneManager::GetCamera()->m_vecFrustumNormal[2],vecMaxBox,vecMinBox) < 0.0f &&
|
||
CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumRight,-CSceneManager::GetCamera()->m_vecFrustumNormal[3],vecMaxBox,vecMinBox) < 0.0f)
|
||
{
|
||
if(m_SectorScene[ix+iy*m_LSizeX].m_MapWater && m_SectorScene[ix+iy*m_LSizeX].m_MapWater->m_bWaterRelection)
|
||
WaterHeightList.AddUnique(m_SectorScene[ix+iy*m_LSizeX].m_MapWater->m_fWaterHeight);
|
||
|
||
IsCulling[ix+iy*m_LSizeX]=true;
|
||
CSceneManager::m_cRenderSector++;
|
||
}
|
||
else
|
||
{
|
||
IsCulling[ix+iy*m_LSizeX]=false;
|
||
}
|
||
}
|
||
}
|
||
int nDetailSector=0;
|
||
int DetailSectorRender[9]={0,};
|
||
|
||
vector3 *vecViewPos=CSceneManager::GetCamera()->GetPosition();
|
||
|
||
//pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
//pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
pDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_TerrainLight);
|
||
|
||
|
||
|
||
pDevice->LightEnable(0,FALSE);
|
||
pDevice->LightEnable(1,FALSE);
|
||
pDevice->LightEnable(2,FALSE);
|
||
pDevice->LightEnable(3,FALSE);
|
||
pDevice->LightEnable(4,FALSE);
|
||
pDevice->LightEnable(5,FALSE);
|
||
pDevice->LightEnable(6,FALSE);
|
||
pDevice->LightEnable(7,FALSE);
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
color TerrainColor;
|
||
TerrainColor.a=0xff;
|
||
TerrainColor.r=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.r*255;
|
||
TerrainColor.g=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.g*255;
|
||
TerrainColor.b=CSceneManager::m_WeatherManager.m_SunLight.Diffuse.b*255;
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,TerrainColor.c);
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterTerrainColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
//pd3dDevice->SetTexture(1,NULL);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
pDevice->SetTransform(D3DTS_WORLD,(D3DMATRIX*)(&m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM));
|
||
|
||
vecMinBox.x=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.z=m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43;
|
||
vecMaxBox.z=vecMinBox.z+SECTORSIZE;
|
||
|
||
if( vecMinBox.x <= vecViewPos->x && vecMaxBox.x >= vecViewPos->x &&
|
||
vecMinBox.z <= vecViewPos->z && vecMaxBox.z >= vecViewPos->z )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderBlackDetail(pDevice);
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.z-vecViewPos->z) <= SECTORSIZE/3.0f || fabsf(vecMaxBox.z-vecViewPos->z) <= SECTORSIZE/3.0f ) &&
|
||
vecMinBox.x <= vecViewPos->x && vecMaxBox.x >= vecViewPos->x )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderBlackDetail(pDevice);
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.x-vecViewPos->x) <= SECTORSIZE/3.0f || fabsf(vecMaxBox.x-vecViewPos->x) <= SECTORSIZE/3.0f ) &&
|
||
vecMinBox.z <= vecViewPos->z && vecMaxBox.z >= vecViewPos->z )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderBlackDetail(pDevice);
|
||
continue;
|
||
}
|
||
|
||
if( (fabsf(vecMinBox.x-vecViewPos->x) <= SECTORSIZE/3.0f ||
|
||
fabsf(vecMaxBox.x-vecViewPos->x) <= SECTORSIZE/3.0f ) &&
|
||
(fabsf(vecMinBox.z-vecViewPos->z) <= SECTORSIZE/3.0f ||
|
||
fabsf(vecMaxBox.z-vecViewPos->z) <= SECTORSIZE/3.0f ) )
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderBlackDetail(pDevice);
|
||
continue;
|
||
}
|
||
|
||
//m_SectorScene[ix+iy*m_LSizeX].Render(pd3dDevice);
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderBlackTerrain(pDevice);
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(m_bHouseCulling) {
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderBlackHouse(pDevice);
|
||
}
|
||
else
|
||
m_SectorScene[ix+iy * m_LSizeX].RenderNotCullHouseObject(pDevice);
|
||
|
||
}
|
||
else { // Culling Off 03.03.04 (arena <20><> <20><><EFBFBD><EFBFBD>)
|
||
m_SectorScene[ix+iy*m_LSizeX].RenderBlackHouse(pDevice);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//////////////////////////////////////////////////
|
||
LPDIRECT3DDEVICE8 pd3dDevice = pDevice;
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 2 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 3, D3DTSS_TEXCOORDINDEX, 3 );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
|
||
//Sector Sorting
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
if(BaseGraphicsLayer::m_VoodooOption)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
D3DXMATRIX matView;
|
||
|
||
matrix *pmatView = CSceneManager::m_ViewCamera->GetMatPosition();
|
||
|
||
pDevice->GetTransform(D3DTS_VIEW,&matView);
|
||
|
||
int Uindexx=(int)((pmatView->_41)/SECTORSIZE);
|
||
int Uindexy=(int)((pmatView->_43)/SECTORSIZE);
|
||
int Sindexx,Sindexy;
|
||
|
||
int iCurrentSector = 0;
|
||
|
||
m_iSortsNum = 0;
|
||
|
||
D3DXVECTOR4 vecViewSectorPos;
|
||
|
||
for(ix=0;ix<m_LSizeX;ix++)
|
||
{
|
||
for(iy=0;iy<m_LSizeY;iy++)
|
||
{
|
||
if(IsCulling[ix+iy*m_LSizeX])
|
||
{
|
||
//D3DXVECTOR3 vecSectorTmPos = D3DXVECTOR3(m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._41,/*m_TM._41,*/pmatView->_42,m_SectorScene[ix+iy*m_LSizeX].m_AccumulateTM._43/*m_TM._43*/);
|
||
D3DXVECTOR3 vecSectorTmPos = D3DXVECTOR3(m_SectorScene[ix+iy*m_LSizeX].m_TM._41,pmatView->_42,m_SectorScene[ix+iy*m_LSizeX].m_TM._43);
|
||
|
||
|
||
D3DXVec3Transform(&vecViewSectorPos,&vecSectorTmPos,&matView);
|
||
|
||
m_pSectorSorts[m_iSortsNum].fViewDist = vecViewSectorPos.z;
|
||
m_pSectorSorts[m_iSortsNum++].iSectorIndex = (ix+iy*m_LSizeX);
|
||
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
|
||
qsort((void *)m_pSectorSorts,(size_t)m_iSortsNum, sizeof(SectorSortNode_t),Sector_tCompare);
|
||
|
||
for(int iSortSector = 0;iSortSector < m_iSortsNum;iSortSector++ )
|
||
{
|
||
CSectorScene *pSort = &(m_SectorScene[m_pSectorSorts[iSortSector].iSectorIndex]);
|
||
|
||
Sindexx=(int)(pSort->m_TM._41/SECTORSIZE);
|
||
Sindexy=(int)(pSort->m_TM._43/SECTORSIZE);
|
||
|
||
if(!((Uindexx == Sindexx) && (Uindexy == Sindexy))) {
|
||
pDevice->LightEnable(0,FALSE);
|
||
pSort->RenderBlackPlant(pDevice);
|
||
}
|
||
else {
|
||
iCurrentSector = m_pSectorSorts[iSortSector].iSectorIndex;
|
||
}
|
||
|
||
}
|
||
// <20><><EFBFBD><EFBFBD> current Sector <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Renderring
|
||
pDevice->LightEnable(0,FALSE);
|
||
m_SectorScene[iCurrentSector].RenderBlackPlant(pDevice);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE, FALSE );
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
pDevice->LightEnable(0,FALSE);
|
||
pDevice->LightEnable(1,FALSE);
|
||
pDevice->LightEnable(2,FALSE);
|
||
pDevice->LightEnable(3,FALSE);
|
||
pDevice->LightEnable(4,FALSE);
|
||
pDevice->LightEnable(5,FALSE);
|
||
pDevice->LightEnable(6,FALSE);
|
||
pDevice->LightEnable(7,FALSE);
|
||
}
|