RiskYourLife/Client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
Client/GameTools/Zallad3D SceneClass/HeightFieldScene.cpp
LGram16 dd97ddec92 Restructure repository to include all source folders 
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>
2025-11-29 20:17:20 +09:00

3195 lines
107 KiB
C++
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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::RenderEnv(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));
m_SectorScene[ix+iy*m_LSizeX].Render(pd3dDevice);
}
}
}
//*/
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
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].RenderEnvHouseObject(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].RenderEnvHouseObject(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);
CSceneManager::m_CharacterManager.RenderEnv(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);
CRenderOption::m_WaterBumpEnvRendering = 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)
{
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);
}
}
}
}
CRenderOption::m_WaterBumpEnvRendering = true;
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);
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].RenderEnvPlant(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_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);
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);
delete [] IsCulling;
}
void CHeightFieldScene::Render(LPDIRECT3DDEVICE8 pd3dDevice,bool bEnv)
{
pd3dDevice->LightEnable(0,TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
if(CSceneManager::GetInView())
{
CHouseObjectScene *pHouse = NULL;
if((pHouse = CSceneManager::GetInViewHouseScene()))
{
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);
pd3dDevice->SetTransform(D3DTS_WORLD,(D3DMATRIX*)(&pHouse->m_AccumulateTM));
pHouse->Render(pd3dDevice);
}
CSceneManager::m_CharacterManager.Render(pd3dDevice);
return;
}
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;
}*/
CWaterScene::Update();
}
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);
}
bool CHeightFieldScene::CheckRayCollision(const D3DXVECTOR3 &vecPos1,const D3DXVECTOR3 &vecPos2)
{
int iMinX,iMaxX,iMinY,iMaxY;
int iSectorX1,iSectorY1,iSectorX2,iSectorY2;
iSectorX1 = (int)(vecPos1.x / SECTORSIZE);
iSectorY1 = (int)(vecPos1.z / SECTORSIZE);
iSectorX2 = (int)(vecPos2.x / SECTORSIZE);
iSectorY2 = (int)(vecPos2.z / SECTORSIZE);
if(iSectorX1 > iSectorX2)
{
iMinX = iSectorX2;
iMaxX = iSectorX1;
}
else
{
iMinX = iSectorX1;
iMaxX = iSectorX2;
}
if(iSectorY1 > iSectorY2)
{
iMinY = iSectorY2;
iMaxY = iSectorY1;
}
else
{
iMinY = iSectorY1;
iMaxY = iSectorY2;
}
int iIndex = -1;
for(int i = iMinX; i <= iMaxX; i++ )
{
for(int j = iMinY; j <= iMaxY; j++ )
{
if((iIndex = GetSectorIndex(i,j)) != -1)
{
if(m_SectorScene[iIndex].CheckRayCollisionHouse(vecPos1,vecPos2))
return true;
}
}
}
return false;
}
int CHeightFieldScene::GetSectorIndex(const int iSX,const int iSY)
{
int iX,iY;
for(int ix=0;ix<m_LSizeX;ix++)
{
for(int iy=0;iy<m_LSizeY;iy++)
{
int iIndex = ix+iy*m_LSizeX;
iX=(int)((m_SectorScene[iIndex].m_TM._41)/SECTORSIZE);
iY=(int)((m_SectorScene[iIndex].m_TM._43)/SECTORSIZE);
if(iSX == iX && iSY == iY)
return iIndex;
}
}
return -1;
}
Reference in New Issue View Git Blame Copy Permalink