LGram16
dd97ddec92
Move git root from Client/ to src/ to track all source code: - Client: Game client source (moved to Client/Client/) - Server: Game server source - GameTools: Development tools - CryptoSource: Encryption utilities - database: Database scripts - Script: Game scripts - rylCoder_16.02.2008_src: Legacy coder tools - GMFont, Game: Additional resources 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
6572 lines
196 KiB
C++
6572 lines
196 KiB
C++
// SceneManager.cpp: implementation of the CSceneManager class.
|
||
//
|
||
//////////////////////////////////////////////////////////////////////
|
||
|
||
#include "SceneManager.h"
|
||
#include <d3dx8.h>
|
||
#include "ConvertTexture.h"
|
||
#include "BaseGraphicsLayer.h"
|
||
#include "SectorSoundMap.h"
|
||
#include "BGMController.h"
|
||
//#include "RenderOption.h"
|
||
#include <exception>
|
||
#include "CCameraScript.h"
|
||
#include "WBEnvPlaneTex.h"
|
||
#include "RainParticle.h"
|
||
#include "ChristmasParticle.h"
|
||
#include "hristmasParticleManager.h"
|
||
#include "SceneStateMgr.h"
|
||
#include "FullSceneEffect.h"
|
||
|
||
using namespace std;
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Construction/Destruction
|
||
//////////////////////////////////////////////////////////////////////
|
||
|
||
CViewCamera* CSceneManager::m_ViewCamera;
|
||
|
||
#define KeyPressed( key ) HIBYTE( GetAsyncKeyState( key ) )
|
||
|
||
// SceneData Container
|
||
CHeightFieldScene CSceneManager::m_HeightField;
|
||
CMeshObjectContainer CSceneManager::m_MeshObjectContainer;
|
||
CHouseObjectContainer CSceneManager::m_HouseObjectContainer;
|
||
CLightContainer CSceneManager::m_LightObjectContainer;
|
||
CObjectContainer CSceneManager::m_ObjectContainer;
|
||
CWeatherManager CSceneManager::m_WeatherManager;
|
||
COctreeContainer CSceneManager::m_OctreeContainer;
|
||
CInstanceObjectManager CSceneManager::m_InstanceObjectManager;
|
||
WBWaterNormalTexGenerator *CSceneManager::m_pWaterTexGenerator = NULL;
|
||
|
||
float CSceneManager::m_fWeatherTimeAdder;
|
||
|
||
CCharacterLightShadowManager CSceneManager::m_CharacterManager;
|
||
//CMapStorage CSceneManager::m_MapStorage;
|
||
//Pick Member
|
||
long CSceneManager::m_bIsPickObjectMoving;
|
||
CHouseObjectScene *CSceneManager::m_PickHouseScene;
|
||
CLightObjectScene *CSceneManager::m_PickLightScene;
|
||
CSectorLandscapeEffectMap *CSceneManager::m_PickLandscape;
|
||
|
||
CObjectScene *CSceneManager::m_PickObjectScene;
|
||
matrix CSceneManager::m_matUndo;
|
||
bool CSceneManager::m_bPickFix=false;
|
||
//Lod Member
|
||
int CSceneManager::m_isTessellate;
|
||
//Detail Member
|
||
long CSceneManager::m_DetailCharShadow;
|
||
long CSceneManager::m_DetailMapShadow;
|
||
long CSceneManager::m_DetailBuildShadow;
|
||
long CSceneManager::m_DetailTerrain;
|
||
long CSceneManager::m_DetailChrMesh;
|
||
long CSceneManager::m_DetailViewRange;
|
||
long CSceneManager::m_DetailWaterReflection;
|
||
long CSceneManager::m_DetailLensflare;
|
||
long CSceneManager::m_DetailTreeDetail;
|
||
//
|
||
LPDIRECT3DDEVICE8 CSceneManager::m_pd3dDevice;
|
||
CCollisionDetection CSceneManager::m_CollisionDetection;
|
||
bool CSceneManager::m_isCollisionDetection;
|
||
//
|
||
|
||
//Particle Manager//
|
||
//CParticleManager CSceneManager::m_ParticleManager;
|
||
|
||
|
||
int CSceneManager::m_ViewerMode;
|
||
|
||
long CSceneManager::m_cRenderVertex;
|
||
long CSceneManager::m_cRenderPolygon;
|
||
long CSceneManager::m_cRenderSector;
|
||
|
||
long CSceneManager::m_cRenderSectorPoly;
|
||
long CSceneManager::m_cRenderSectorVertex;
|
||
long CSceneManager::m_cRenderPrimitive;
|
||
|
||
vector3 CSceneManager::m_vecPickRayStart;
|
||
vector3 CSceneManager::m_vecPickRayDir;
|
||
|
||
float CSceneManager::m_fRemainFrame;
|
||
|
||
bool CSceneManager::m_bEditor;
|
||
|
||
CTexture CSceneManager::m_NsTexture;
|
||
|
||
float CSceneManager::m_fChrCameraInter;
|
||
float CSceneManager::m_fWeatherTime;
|
||
|
||
//CBoidScene CSceneManager::m_Boid;
|
||
|
||
CHouseObjectScene *CSceneManager::m_pBspScene=NULL;
|
||
List<vector3> CSceneManager::m_vecBspConvertList;
|
||
List<CHouseObjectScene*> CSceneManager::m_pBspConvertList;
|
||
List<vector3> CSceneManager::m_vecFieldConvertList;
|
||
CX3DEffectManager CSceneManager::m_EffectManager;
|
||
|
||
|
||
CSectorEffectMap *CSceneManager::m_Effect_Map;
|
||
|
||
CSectorEffectMap *CSceneManager::m_PickEffect;
|
||
BOOL CSceneManager::m_bPickEffect;
|
||
int CSceneManager::m_EffectNum;
|
||
|
||
CTexture CSceneManager::m_ChracterEnvTexture;
|
||
|
||
LPDIRECT3DCUBETEXTURE8 CSceneManager::m_LightCubeTexture;
|
||
List<CSceneManager::CGlareNode> CSceneManager::m_GlareList;
|
||
CRenderEnvTexture CSceneManager::m_DiffuseLightCubeTexture;
|
||
CRenderEnvTexture CSceneManager::m_SpecularLightTexture;
|
||
CRenderTexture CSceneManager::m_SpGlareTexture;
|
||
|
||
|
||
CLightEffectManager CSceneManager::m_LightEffectManager;
|
||
color CSceneManager::m_FullSceneFade;
|
||
|
||
char CSceneManager::m_SceneManagerPath[256];
|
||
//ũ<><C5A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>
|
||
CSnowFall CSceneManager::m_SnowFall;
|
||
CRenderOption::ZoneInfo CSceneManager::m_ZoneInfoData;
|
||
//////////////////////////BSP<53>߰<EFBFBD>
|
||
RBspSceneManager CSceneManager::m_RBspSceneManager;
|
||
bool CSceneManager::m_bRBspSceneIn = false;
|
||
//// Sector Light
|
||
CSectorLight *CSceneManager::m_pPickSectorLight = NULL;
|
||
bool CSceneManager::m_bRenderSectorLight = true;
|
||
|
||
D3DLIGHT8 CSceneManager::m_CharacterLight;
|
||
bool CSceneManager::m_bCharacterLight;
|
||
float CSceneManager::m_fGlowPlaneRange;
|
||
bool CSceneManager::m_bCharacterLightOp;
|
||
|
||
bool CSceneManager::m_bSectorLightFactor = false;
|
||
DWORD CSceneManager::m_dwSectorLightFactor = 0xffffffff;
|
||
|
||
CCameraScript *g_CameraScript = NULL;
|
||
|
||
CShaderManager CSceneManager::m_ShaderManager;
|
||
WBEnvPlaneTex *CSceneManager::m_pEnvPlaneTex = NULL;
|
||
CGlareManager *CSceneManager::m_GlareManager = NULL;
|
||
bool CSceneManager::m_bEnv = false;
|
||
CTexture *CSceneManager::m_pBlackGlare = NULL;
|
||
|
||
CEffectCasher *CSceneManager::m_pEsfCasher = NULL;
|
||
int g_iBlurTextureNum = 6;
|
||
int g_iBlurCount = 0;
|
||
D3DXVECTOR3 CSceneManager::m_vecLifeColor;
|
||
CFullSceneEffect *CSceneManager::m_pFullSceneEffect = NULL;
|
||
bool CSceneManager::m_bSceneNodeCulling = true;
|
||
bool CSceneManager::m_bMinimapGenerate = false;
|
||
CSectorScene *CSceneManager::m_pPickSector = NULL;
|
||
|
||
IDirect3DCubeTexture8* CSceneManager::m_pWorldCubemap = NULL;
|
||
ID3DXRenderToEnvMap* CSceneManager::m_pRenderEnvMap = NULL;
|
||
|
||
bool CSceneManager::m_bInView = false; // true <20>϶<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>
|
||
CHouseObjectScene *CSceneManager::m_pInViewHouseScene = NULL;
|
||
|
||
//Caldron::Base::CResourceLoader *CSceneManager::m_pResourceLoader = NULL;
|
||
//CCaldronHouseCacheMgr *CSceneManager::m_pCaldronHouseCacheMgr = NULL;
|
||
|
||
|
||
CSceneManager::CSceneManager()
|
||
{
|
||
//LogMessage("Constructor SceneManager");
|
||
m_isTessellate=1;
|
||
m_PickHouseScene=NULL;
|
||
m_bIsPickObjectMoving=0;
|
||
m_fWeatherTimeAdder=0.001f;
|
||
m_ViewerMode=0;
|
||
m_fRemainFrame=0;
|
||
m_isCollisionDetection=false;
|
||
m_bEditor=false;
|
||
m_fChrCameraInter=350.0f;
|
||
m_fWeatherTime=0.0f;
|
||
m_fWeatherTimeAdder=0.0f;
|
||
m_EffectNum = 0;
|
||
m_bPickEffect = NULL;
|
||
m_PickLandscape = NULL;
|
||
m_ScreenSize=1024;
|
||
m_FullSceneFade.c=0x0;
|
||
|
||
strcpy(m_SceneManagerPath,"");
|
||
m_bSnowFall = false;
|
||
|
||
memset(&m_CharacterLight,0,sizeof(D3DLIGHT8));
|
||
m_CharacterLight.Type=D3DLIGHT_POINT;
|
||
/* m_CharacterLight.Attenuation0=0.2f;
|
||
m_CharacterLight.Attenuation1=0.005f;
|
||
m_CharacterLight.Attenuation2=0.0f;
|
||
*/
|
||
|
||
m_CharacterLight.Attenuation0=0.6f;
|
||
m_CharacterLight.Attenuation1=0.001f;
|
||
m_CharacterLight.Attenuation2=0.0f;
|
||
|
||
m_CharacterLight.Diffuse.r = 227.0f / 255.0f;
|
||
m_CharacterLight.Diffuse.g = 186.0f / 255.0f;
|
||
m_CharacterLight.Diffuse.b = 31.0f / 255.0f;
|
||
|
||
m_CharacterLight.Position.x = 0.0f;
|
||
m_CharacterLight.Position.y = 0.0f;
|
||
m_CharacterLight.Position.z = 0.0f;
|
||
m_CharacterLight.Range= 1500.0f;
|
||
m_CharacterLight.Falloff = 1.0f;
|
||
|
||
m_fGlowPlaneRange = 800.0f;
|
||
|
||
m_bCharacterLight = true;
|
||
m_bCharacterLightOp = true;
|
||
m_pBlackGlare = NULL;
|
||
m_pRainParticle = NULL;
|
||
m_pChristmasParticle = NULL;
|
||
m_pChristmasParticleManager = NULL;
|
||
m_bChristmas = true;
|
||
|
||
srand(time(0));
|
||
m_pFullSceneEffect = NULL;
|
||
m_pFullsceneEffect2 = NULL;
|
||
|
||
m_vecLifeColor = D3DXVECTOR3(0.0f,0.0f,0.0f);
|
||
m_pRenderEnvMap = NULL;
|
||
m_pWorldCubemap = NULL;
|
||
m_bInView = false;
|
||
m_pInViewHouseScene = NULL;
|
||
|
||
// m_pResourceLoader = new Caldron::Base::CResourceLoader();
|
||
// m_pCaldronHouseCacheMgr = new CCaldronHouseCacheMgr();
|
||
|
||
|
||
|
||
}
|
||
|
||
CSceneManager::~CSceneManager()
|
||
{
|
||
//CMapStorage::DeleteAllData();
|
||
m_MapStorage.DeleteAllObject();
|
||
m_HouseObjectContainer.DeleteAllObject();
|
||
m_LightObjectContainer.DeleteAllObject();
|
||
m_ObjectContainer.DeleteAllObject();
|
||
m_MeshObjectContainer.DeleteAllObject();
|
||
m_OctreeContainer.DeleteAllObject();
|
||
if(CGrassScene::m_NormalTexture != NULL)
|
||
{
|
||
delete CGrassScene::m_NormalTexture;
|
||
CGrassScene::m_NormalTexture = NULL;
|
||
}
|
||
/**/ if(m_pWaterTexGenerator != NULL)
|
||
{
|
||
delete m_pWaterTexGenerator;
|
||
m_pWaterTexGenerator = NULL;
|
||
}
|
||
if(m_pEnvPlaneTex != NULL)
|
||
delete m_pEnvPlaneTex;
|
||
|
||
if(m_GlareManager != NULL)
|
||
delete m_GlareManager;
|
||
|
||
if(m_pBlackGlare != NULL) {
|
||
delete m_pBlackGlare;
|
||
m_pBlackGlare = NULL;
|
||
}
|
||
|
||
if(m_pRainParticle != NULL) {
|
||
delete m_pRainParticle;
|
||
m_pRainParticle = NULL;
|
||
}
|
||
if(m_pChristmasParticle != NULL) {
|
||
delete m_pChristmasParticle;
|
||
m_pChristmasParticle = NULL;
|
||
|
||
}
|
||
if(m_pChristmasParticleManager) {
|
||
delete m_pChristmasParticleManager;
|
||
m_pChristmasParticleManager = NULL;
|
||
}
|
||
|
||
if(m_pEsfCasher != NULL) {
|
||
delete m_pEsfCasher;
|
||
m_pEsfCasher = NULL;
|
||
}
|
||
if(m_pFullSceneEffect) {
|
||
delete m_pFullSceneEffect;
|
||
m_pFullSceneEffect = NULL;
|
||
}
|
||
if(m_pFullsceneEffect2) {
|
||
delete m_pFullsceneEffect2;
|
||
m_pFullsceneEffect2 = NULL;
|
||
}
|
||
/* if(m_pResourceLoader)
|
||
{
|
||
delete m_pResourceLoader;
|
||
m_pResourceLoader = NULL;
|
||
|
||
}
|
||
if(m_pCaldronHouseCacheMgr)
|
||
{
|
||
delete m_pCaldronHouseCacheMgr;
|
||
m_pCaldronHouseCacheMgr = NULL;
|
||
}*/
|
||
if(m_pRenderEnvMap)
|
||
{
|
||
m_pRenderEnvMap->Release();
|
||
}
|
||
|
||
if(m_pWorldCubemap)
|
||
{
|
||
m_pWorldCubemap->Release();
|
||
}
|
||
}
|
||
|
||
void CSceneManager::Create()
|
||
{
|
||
|
||
m_bEditor=true;
|
||
m_DetailCharShadow=4;
|
||
m_DetailMapShadow=4;
|
||
m_DetailBuildShadow=4;
|
||
m_DetailTerrain=4;
|
||
m_DetailChrMesh=4;
|
||
m_DetailViewRange=4;
|
||
m_DetailWaterReflection=4;
|
||
m_DetailLensflare=4;
|
||
m_DetailTreeDetail=4;
|
||
CPerlinNoise::Init();
|
||
|
||
SHADOWSIZE=256;
|
||
|
||
|
||
char path[256];
|
||
GetCurrentDirectory(256,path);
|
||
SetSceneManagerPath(path);
|
||
|
||
CSceneStateMgr::_Init();
|
||
|
||
m_HeightField.Create(CRenderOption::m_TerrainRange,CRenderOption::m_TerrainRange,&m_MapStorage);
|
||
m_HeightField.CheckingNextTerrain();
|
||
m_CollisionDetection.m_HeightField=&m_HeightField;
|
||
|
||
// CParticle::SetMatPosition(&m_ViewCamera->m_matPosition);
|
||
m_InstanceObjectManager.Create(m_pd3dDevice);
|
||
DETAILGROUND=25;
|
||
|
||
m_EffectManager.SetDevice(m_pd3dDevice);
|
||
|
||
//m_Boid.Create(100,0);
|
||
|
||
CRenderTargetTexture::Create(m_pd3dDevice,SHADOWSIZE,SHADOWSIZE);
|
||
LENS_REALPOLYTREE=12000.0f;
|
||
|
||
//m_CharacterManager.Create();
|
||
//m_CharacterManager.SetHeightField(&m_HeightField);
|
||
|
||
CHRTEXTURESIZE=0;
|
||
|
||
m_LightCubeTexture=NULL;
|
||
|
||
if(CRenderOption::m_FullSceneGlare)
|
||
{
|
||
/*
|
||
m_GlareTexture.Create(m_ScreenSize,m_ScreenSize);
|
||
m_FullSceneTexture.Create(m_ScreenSize,m_ScreenSize);
|
||
m_SpecularGlareTexture.Create(m_ScreenSize,m_ScreenSize);
|
||
|
||
m_GlareCompositeTexture.Create(256,256);
|
||
|
||
m_FullSceneAnti=true;
|
||
|
||
CTexture::SetPath(NATURETEXTUREPATH);
|
||
m_ChracterEnvTexture.Load("Env.dds");
|
||
|
||
char strCubeTextureName[256];
|
||
sprintf(strCubeTextureName,"%s\\%s",NATURETEXTUREPATH,"LightCubemap.dds");
|
||
|
||
D3DXCreateCubeTextureFromFileExA(m_pd3dDevice,
|
||
strCubeTextureName,
|
||
D3DX_DEFAULT,
|
||
0,
|
||
0,
|
||
D3DFMT_UNKNOWN,
|
||
D3DPOOL_MANAGED,
|
||
D3DX_FILTER_LINEAR,
|
||
D3DX_FILTER_LINEAR,
|
||
0,
|
||
NULL,
|
||
NULL,
|
||
&m_LightCubeTexture);
|
||
|
||
//sprintf(strCubeTextureName,"%s\\%s",NATURETEXTUREPATH,"LightCubemap.dds");
|
||
|
||
m_DiffuseLightCubeTexture.Create(m_pd3dDevice,"sky",NATURETEXTUREPATH);
|
||
m_SpecularLightTexture.Create(m_pd3dDevice,"sp_light",NATURETEXTUREPATH,false);
|
||
|
||
m_SpGlareTexture.Create(256,256);
|
||
|
||
m_SmoothGlareTexture.Create(128);
|
||
*/
|
||
m_LightEffectManager.Create(m_ScreenSize);
|
||
|
||
}
|
||
|
||
|
||
|
||
//m_GlareTexture.Create(256,256);
|
||
|
||
//CShadowMap::Create(512,512);
|
||
|
||
//m_CharacterManager.CreateEditor();
|
||
|
||
//CParticleManager::AddParticle(SMOKE_PARTICLE,vector3(0.0f,0.0f,0.0f),vector3(1.0f,1.0f,0.0f));
|
||
|
||
|
||
///m_GrassScene.Create();
|
||
//
|
||
//m_pShip.Load("c:\\MP-Project\\Objects\\Object\\flying-trans-1.R3S");
|
||
//CTexture::SetPath(OBJECTTEXTUREPATH);
|
||
//m_pShip.TextureLoad();
|
||
//m_pShip.ConvertNormal();
|
||
|
||
//m_AniObject.Load("c:\\test.R3A");
|
||
|
||
//strcpy(CRenderOption::m_strBaseGraphicsDataPath,"Zone2");
|
||
//strcpy(CRenderOption::m_strBaseGraphicsDataPath,"");
|
||
BaseGraphicsDataLoad(CRenderOption::m_strBaseGraphicsDataPath);
|
||
m_WeatherManager.Create();
|
||
m_CharacterManager.Create();
|
||
m_CharacterManager.SetHeightField(&m_HeightField);
|
||
g_CameraScript = new CCameraScript;
|
||
m_ShaderManager.Init();
|
||
/**/ if(m_pWaterTexGenerator == NULL) {
|
||
m_pWaterTexGenerator = new WBWaterNormalTexGenerator;
|
||
m_pWaterTexGenerator->Init(GetDevice(),256,256,"Displacement.dds");
|
||
}
|
||
if(m_pEnvPlaneTex != NULL)
|
||
delete m_pEnvPlaneTex;
|
||
|
||
|
||
m_pEnvPlaneTex = new WBEnvPlaneTex;
|
||
m_pEnvPlaneTex->Init(GetDevice(),256,256);
|
||
//===================
|
||
// Glare Test
|
||
//===================
|
||
m_GlareManager = new CGlareManager;
|
||
m_GlareManager->Create();
|
||
|
||
if(m_pBlackGlare != NULL)
|
||
delete m_pBlackGlare;
|
||
m_pBlackGlare = new CTexture;
|
||
CTexture::SetPath(EFFECTTEXTUREPATH);
|
||
m_pBlackGlare->Load("spec_black.dds");
|
||
///////////////////ũ<><C5A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>
|
||
|
||
if(m_bSnowFall) {
|
||
D3DXMATRIX tmpview;
|
||
m_pd3dDevice->GetTransform(D3DTS_VIEW,&tmpview);
|
||
D3DXMatrixInverse(&tmpview,NULL,&tmpview);
|
||
|
||
vector3 tmppos;
|
||
tmppos.x = tmpview._41;
|
||
tmppos.y = tmpview._42;
|
||
tmppos.z = tmpview._43;
|
||
/*m_SnowFall.SetWorldValue(0.0f,-2.0f,0.0f,8.0f,-3.0f,8.0f,"snow.dds");
|
||
//m_SnowFall.Init(GetDevice(),300,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 100.0f);
|
||
m_SnowFall.Init(GetDevice(),500,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 2000.0f);
|
||
*/
|
||
|
||
m_SnowFall.SetWorldValue(0.0f,-15.0f,0.0f,1.0f,-0.5f,1.0f,"snow.dds");
|
||
//m_SnowFall.Init(GetDevice(),300,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 100.0f);
|
||
m_SnowFall.Init(GetDevice(),200,tmppos.x,tmppos.y,tmppos.z,500.0f,500.0f,tmppos.y + 2000.0f);
|
||
}
|
||
|
||
if(CRenderOption::m_bRain) {
|
||
m_pRainParticle = new CRainParticle;
|
||
|
||
m_pRainParticle->Init(1000,"RainPar.dds");
|
||
m_pRainParticle->SetMaxLife(75.0f);
|
||
m_pRainParticle->Explode(0.12f, 777 );
|
||
m_pRainParticle->SetVisible(1.0f,0.2f);
|
||
m_pRainParticle->SetBaseMass(1.2f);
|
||
m_pRainParticle->SetFraction(0.0f);
|
||
m_pRainParticle->SetGravity( 10.5f, -0.980001f, 0.0f );
|
||
|
||
|
||
m_pRainParticle->SetColor(1.0f,1.0f,1.0f,1.0f,1.0f,1.0f);
|
||
m_pRainParticle->SetSize(0.1f,3.5f,0.1f,3.5f);
|
||
|
||
|
||
|
||
/*m_pRainParticle->SetColor(0.6f,0.6f,0.6f,0.6f,0.6f,0.6f);
|
||
m_pRainParticle->SetSize(0.1f,3.5f,0.1f,3.5f);
|
||
|
||
m_pChristmasParticle = new CChristmasParticle;
|
||
m_pChristmasParticle->Init(900,"CParticle.dds");
|
||
m_pChristmasParticle->SetMaxLife(75.0f);
|
||
m_pChristmasParticle->SetVisible(1.0f,0.0f);
|
||
m_pChristmasParticle->SetBaseMass(1.2f);
|
||
m_pChristmasParticle->SetFraction(0.0f);
|
||
m_pChristmasParticle->SetGravity( 0.0f, -0.1f, 0.0f );
|
||
m_pChristmasParticle->SetColor(1.0f,1.0f,1.0f,0.0f,0.0f,0.0f);
|
||
m_pChristmasParticle->SetSize(4.0f,4.0f,4.0f,4.0f);
|
||
*/
|
||
|
||
}
|
||
if(m_bChristmas) {
|
||
m_pChristmasParticleManager = new CChristmasParticleManager;
|
||
|
||
}
|
||
/* if(m_pEsfCasher) {
|
||
delete m_pEsfCasher;
|
||
|
||
}
|
||
m_pEsfCasher = new CEffectCasher;
|
||
m_pEsfCasher->BuildHashTable(EFFECTSCRIPTPATH);
|
||
*/
|
||
|
||
if(m_pFullSceneEffect) {
|
||
delete m_pFullSceneEffect;
|
||
m_pFullSceneEffect = NULL;
|
||
}
|
||
m_pFullSceneEffect = new CFullSceneEffect;
|
||
m_pFullSceneEffect->SetFullSceneEffectEnable(CRenderOption::m_bFullSceneEffect);
|
||
m_pFullSceneEffect->Init(GetDevice());
|
||
m_pFullSceneEffect->SetFlag(11,true); //FullScene Glare
|
||
// m_pFullSceneEffect->SetFlag(9,true);
|
||
// Blur Enable
|
||
//m_pFullSceneEffect->SetFlag(1,true);
|
||
|
||
|
||
/* FULLSCENE_MOTIONBLUR = 0,
|
||
FULLSCENE_BRIGHT,
|
||
FULLSCENE_BLACK,
|
||
FULLSCENE_CONTRAST,
|
||
FULLSCENE_LEVEL,
|
||
FULLSCENE_GRAYLEVEL,
|
||
FULLSCENE_EDGE,
|
||
FULLSCENE_NEGATIVE,
|
||
FULLSCENE_SEPIA,
|
||
FULLSCENE_SOLAR,
|
||
FULLSCENE_NUMS,
|
||
*/
|
||
///////////////
|
||
|
||
// Cubemap Generation
|
||
//////////////
|
||
if(CRenderOption::m_WaterBumpEnvRendering)
|
||
{
|
||
D3DXCreateRenderToEnvMap( BaseGraphicsLayer::GetDevice(), 256,
|
||
BaseGraphicsLayer::m_d3dpp.BackBufferFormat, TRUE, D3DFMT_D16, &m_pRenderEnvMap );
|
||
|
||
D3DXCreateCubeTexture( BaseGraphicsLayer::GetDevice(), 256, 1,
|
||
D3DUSAGE_RENDERTARGET,BaseGraphicsLayer::m_d3dpp.BackBufferFormat, D3DPOOL_DEFAULT, &m_pWorldCubemap );
|
||
}
|
||
//////////////
|
||
}
|
||
|
||
|
||
D3DXMATRIX D3DUtil_RGetCubeMapViewMatrix( DWORD dwFace )
|
||
{
|
||
D3DXVECTOR3 vEyePt = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
|
||
D3DXVECTOR3 vLookDir;
|
||
D3DXVECTOR3 vUpDir;
|
||
|
||
switch( dwFace )
|
||
{
|
||
case D3DCUBEMAP_FACE_POSITIVE_X:
|
||
vLookDir = D3DXVECTOR3( 1.0f, 0.0f, 0.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
break;
|
||
case D3DCUBEMAP_FACE_NEGATIVE_X:
|
||
vLookDir = D3DXVECTOR3(-1.0f, 0.0f, 0.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
break;
|
||
case D3DCUBEMAP_FACE_POSITIVE_Y:
|
||
vLookDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
|
||
break;
|
||
case D3DCUBEMAP_FACE_NEGATIVE_Y:
|
||
vLookDir = D3DXVECTOR3( 0.0f,-1.0f, 0.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
|
||
break;
|
||
case D3DCUBEMAP_FACE_POSITIVE_Z:
|
||
vLookDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
break;
|
||
case D3DCUBEMAP_FACE_NEGATIVE_Z:
|
||
vLookDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
break;
|
||
}
|
||
|
||
// Set the view transform for this cubemap surface
|
||
D3DXMATRIX matView;
|
||
D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookDir, &vUpDir );
|
||
return matView;
|
||
}
|
||
|
||
D3DXMATRIX DD3DUtil_GetCubeMapViewMatrix( DWORD dwFace )
|
||
{
|
||
D3DXVECTOR3 vEyePt = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
|
||
D3DXVECTOR3 vLookDir;
|
||
D3DXVECTOR3 vUpDir;
|
||
|
||
switch( dwFace )
|
||
{
|
||
case D3DCUBEMAP_FACE_POSITIVE_X:
|
||
vLookDir = D3DXVECTOR3( 1.0f, 0.0f, 0.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
break;
|
||
case D3DCUBEMAP_FACE_NEGATIVE_X:
|
||
vLookDir = D3DXVECTOR3(-1.0f, 0.0f, 0.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
break;
|
||
case D3DCUBEMAP_FACE_POSITIVE_Y:
|
||
vLookDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
|
||
break;
|
||
case D3DCUBEMAP_FACE_NEGATIVE_Y:
|
||
vLookDir = D3DXVECTOR3( 0.0f,-1.0f, 0.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
|
||
break;
|
||
case D3DCUBEMAP_FACE_POSITIVE_Z:
|
||
vLookDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
break;
|
||
case D3DCUBEMAP_FACE_NEGATIVE_Z:
|
||
vLookDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
break;
|
||
}
|
||
|
||
// Set the view transform for this cubemap surface
|
||
D3DXMATRIX matView;
|
||
D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookDir, &vUpDir );
|
||
return matView;
|
||
};
|
||
|
||
|
||
|
||
const long T3LVERTEXFVF=D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1|D3DFVF_TEXCOORDSIZE3(0);
|
||
class T3LVertex
|
||
{
|
||
public:
|
||
vector3 v;
|
||
float w;
|
||
color Diffuse;
|
||
color Specular;
|
||
float tu,tv,tw;
|
||
};
|
||
|
||
|
||
void CSceneManager::Render()
|
||
{
|
||
|
||
|
||
D3DVIEWPORT8 Viewport;
|
||
|
||
m_pd3dDevice->GetViewport(&Viewport);
|
||
|
||
/*
|
||
m_pd3dDevice->EndScene();
|
||
m_DiffuseLightCubeTexture.RenderCubeMap(m_pd3dDevice);
|
||
m_pd3dDevice->BeginScene();
|
||
|
||
m_pd3dDevice->EndScene();
|
||
m_SpGlareTexture.Begin(m_pd3dDevice);
|
||
m_pd3dDevice->BeginScene();
|
||
m_pd3dDevice->Clear(0, NULL, D3DCLEAR_ZBUFFER|D3DCLEAR_TARGET,0x0,1.0f, 0);
|
||
|
||
D3DXMATRIX matProj;
|
||
|
||
D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI/2.0f , 1.0f, 100.0f, 2000.0f );
|
||
|
||
D3DXMATRIX matOldView,matOldProjection;
|
||
m_pd3dDevice->GetTransform(D3DTS_VIEW,&matOldView);
|
||
m_pd3dDevice->GetTransform(D3DTS_PROJECTION,&matOldProjection);
|
||
|
||
D3DXMATRIX matViewDir( matOldView);
|
||
matViewDir._41 = 0.0f; matViewDir._42 = 0.0f; matViewDir._43 = 0.0f;
|
||
|
||
|
||
D3DXMATRIX matView;
|
||
matView =matViewDir;
|
||
//matView = DD3DUtil_GetCubeMapViewMatrix( (D3DCUBEMAP_FACES) 1 );
|
||
//D3DXMatrixMultiply( &matView, &matViewDir, &matView );
|
||
//D3DXMatrixMultiply( &matView, &matView ,&matViewDir );
|
||
|
||
|
||
|
||
m_pd3dDevice->SetTransform(D3DTS_VIEW,&matView);
|
||
m_pd3dDevice->SetTransform(D3DTS_PROJECTION,&matProj);
|
||
|
||
m_SpecularLightTexture.RenderSkymap(m_pd3dDevice);
|
||
//m_DiffuseLightCubeTexture.RenderSkymap(m_pd3dDevice);
|
||
|
||
vector3 vecSunPos;
|
||
vector3 vecProjPos;
|
||
float w;
|
||
vecSunPos=vector3(-1000.0f,-500.0f,-1000.0f);
|
||
bool isInScreenSun=BaseGraphicsLayer::TransformVector(vecSunPos,vecProjPos,w);
|
||
|
||
TLVertex m_SunVertex[4];
|
||
|
||
float sx=100.0f;
|
||
float sy=100.0f;
|
||
m_SunVertex[0].v=vecProjPos;
|
||
m_SunVertex[1].v=vecProjPos;
|
||
m_SunVertex[2].v=vecProjPos;
|
||
m_SunVertex[3].v=vecProjPos;
|
||
|
||
m_SunVertex[0].v.x-=sx;m_SunVertex[0].v.y+=sy;
|
||
m_SunVertex[1].v.x-=sx;m_SunVertex[1].v.y-=sy;
|
||
m_SunVertex[2].v.x+=sx;m_SunVertex[2].v.y+=sy;
|
||
m_SunVertex[3].v.x+=sx;m_SunVertex[3].v.y-=sy;
|
||
|
||
m_SunVertex[0].w=w;
|
||
m_SunVertex[1].w=w;
|
||
m_SunVertex[2].w=w;
|
||
m_SunVertex[3].w=w;
|
||
|
||
m_SunVertex[0].Diffuse.c=0xffffffff;
|
||
m_SunVertex[1].Diffuse.c=0xffffffff;
|
||
m_SunVertex[2].Diffuse.c=0xffffffff;
|
||
m_SunVertex[3].Diffuse.c=0xffffffff;
|
||
|
||
m_SunVertex[0].tu=0.0f;
|
||
m_SunVertex[0].tv=1.0f;
|
||
m_SunVertex[0].Specular.c=0x0;
|
||
|
||
m_SunVertex[1].tu=0.0f;
|
||
m_SunVertex[1].tv=0.0f;
|
||
m_SunVertex[1].Specular.c=0x0;
|
||
|
||
m_SunVertex[2].tu=1.0f;
|
||
m_SunVertex[2].tv=1.0f;
|
||
m_SunVertex[2].Specular.c=0x0;
|
||
|
||
m_SunVertex[3].tu=1.0f;
|
||
m_SunVertex[3].tv=0.0f;
|
||
m_SunVertex[3].Specular.c=0x0;
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
|
||
|
||
//m_pd3dDevice->SetTexture(0,);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
m_pd3dDevice->SetVertexShader(TLVERTEXFVF);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);
|
||
|
||
m_pd3dDevice->SetTexture(0,m_WeatherManager.m_SunScene.m_SunTexture.GetTexture());
|
||
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,m_SunVertex,sizeof(TLVertex));
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
|
||
m_pd3dDevice->SetTransform(D3DTS_VIEW,&matOldView);
|
||
m_pd3dDevice->SetTransform(D3DTS_PROJECTION,&matOldProjection);
|
||
m_pd3dDevice->EndScene();
|
||
m_SpGlareTexture.End(m_pd3dDevice);
|
||
m_pd3dDevice->BeginScene();
|
||
|
||
|
||
|
||
m_pd3dDevice->EndScene();
|
||
m_SpecularLightTexture.RenderCubeMap(m_pd3dDevice);
|
||
m_pd3dDevice->BeginScene();
|
||
|
||
|
||
if(GF3OPTION)
|
||
{
|
||
RenderFullSceneTextureBegin();
|
||
}
|
||
*/
|
||
|
||
////////////////////
|
||
m_pFullSceneEffect->BeginRender(BaseGraphicsLayer::m_ClearColor.c);
|
||
|
||
/////////////////////
|
||
|
||
if(g_CameraScript->ISPlay()) {
|
||
D3DXMATRIX tmp = g_CameraScript->GetCurrentViewMat();
|
||
D3DXVECTOR3 vecCameraPos = g_CameraScript->GetVecPos();
|
||
D3DXVECTOR3 vecCameraUp = g_CameraScript->GetVecUp();
|
||
D3DXVECTOR3 vecCameraLook = g_CameraScript->GetVecLook();
|
||
|
||
m_ViewCamera->LookAt(vector3(vecCameraPos.x,vecCameraPos.y,vecCameraPos.z),
|
||
vector3(vecCameraLook.x,vecCameraLook.y,vecCameraLook.z),
|
||
vector3(vecCameraUp.x,vecCameraUp.y,vecCameraUp.z));
|
||
|
||
m_pd3dDevice->SetTransform(D3DTS_VIEW,m_ViewCamera->GetMatView());
|
||
|
||
//m_pd3dDevice->SetTransform( D3DTS_VIEW ,&tmp);
|
||
|
||
}
|
||
|
||
if(CRenderOption::m_FullSceneGlare)
|
||
{
|
||
m_LightEffectManager.PrepareLightingEnvmap(m_pd3dDevice);
|
||
}
|
||
|
||
m_RBspSceneManager.Render();
|
||
|
||
D3DVIEWPORT8 m_pTempViewPort;
|
||
|
||
bool bRenderEnv = false;
|
||
|
||
if(m_RBspSceneManager.m_pCurrentBspScene == NULL)
|
||
{
|
||
|
||
|
||
if(m_bMinimapGenerate)
|
||
{
|
||
m_bMinimapGenerate = false;
|
||
m_bSceneNodeCulling = false;
|
||
|
||
CFullSceneEffect *pScene = NULL;
|
||
matrix *matPos= m_ViewCamera->GetMatPosition();
|
||
pScene = new CFullSceneEffect;
|
||
pScene->SetFullSceneEffectEnable(true);
|
||
pScene->Init(m_pd3dDevice,256,256);
|
||
|
||
|
||
m_pFullSceneEffect->EndRender();
|
||
pScene->BeginRender(BaseGraphicsLayer::m_ClearColor.c);
|
||
vector3 vecViewPos=matPos->GetLoc();
|
||
|
||
matrix matInit;
|
||
matrix matProjection,matView;
|
||
D3DXMATRIX matOldProjection,matOldView;
|
||
|
||
m_pd3dDevice->GetTransform(D3DTS_PROJECTION,(D3DMATRIX*)&matOldProjection);
|
||
m_pd3dDevice->GetTransform(D3DTS_VIEW,(D3DMATRIX*)&matOldView);
|
||
|
||
matInit.MakeIdent();
|
||
|
||
CSectorScene *pCenterSectorScene=NULL;
|
||
for(int i=0;i<LSIZEX*LSIZEY;i++)
|
||
{
|
||
if( m_HeightField.m_SectorScene[i].m_AccumulateTM._41 <= vecViewPos.x &&
|
||
vecViewPos.x <= m_HeightField.m_SectorScene[i].m_AccumulateTM._41+SECTORSIZE &&
|
||
m_HeightField.m_SectorScene[i].m_AccumulateTM._43 <= vecViewPos.z &&
|
||
vecViewPos.z<= m_HeightField.m_SectorScene[i].m_AccumulateTM._43+SECTORSIZE )
|
||
{
|
||
pCenterSectorScene=&m_HeightField.m_SectorScene[i];
|
||
break;
|
||
}
|
||
|
||
}
|
||
float fStartX = pCenterSectorScene->m_AccumulateTM._41;
|
||
float fStartZ = pCenterSectorScene->m_AccumulateTM._43;
|
||
|
||
int SectorPx=(int)(pCenterSectorScene->m_AccumulateTM._41/SECTORSIZE);
|
||
int SectorPy=(int)(pCenterSectorScene->m_AccumulateTM._43/SECTORSIZE);
|
||
|
||
//float fViewHeight=(SECTORSIZE/2.0f)/tanf(3.14159f/6.0f) + 100.0f;
|
||
float fViewHeight=60000.0f;
|
||
|
||
matrix *matpPos = m_ViewCamera->GetMatPosition();
|
||
matpPos->_41 = fStartX + SECTORSIZE/2.0f;
|
||
matpPos->_42 = fViewHeight;
|
||
matpPos->_43 = fStartZ + SECTORSIZE/2.0f;
|
||
|
||
matrix *matViewCamera = (matrix *)m_ViewCamera->GetMatView();
|
||
matViewCamera->_41 = fStartX + SECTORSIZE/2.0f;
|
||
matViewCamera->_42 = 0.0f;
|
||
matViewCamera->_43 = fStartZ + SECTORSIZE/2.0f;
|
||
matView.CameraLookAt(vector3(fStartX + SECTORSIZE/2.0f,fViewHeight,fStartZ + SECTORSIZE/2.0f),vector3(fStartX + SECTORSIZE/2.0f,0.0f,fStartZ + SECTORSIZE/2.0f),vector3(0.0f,0.0f,1.0f));
|
||
|
||
D3DXMatrixOrthoLH(matProjection,SECTORSIZE,SECTORSIZE,10.0f, 100000.0f);
|
||
m_pd3dDevice->SetTransform(D3DTS_PROJECTION,(D3DMATRIX*)&matProjection);
|
||
m_pd3dDevice->SetTransform(D3DTS_VIEW,(D3DMATRIX*)&matView);
|
||
m_HeightField.RenderMinimap(m_pd3dDevice);
|
||
|
||
pScene->EndRender();
|
||
char strTextureFileName[256];
|
||
sprintf(strTextureFileName,"%s\\Minimap\\%d_%d.dds",WIDETEXTUREPATH,SectorPx,SectorPy);
|
||
|
||
pScene->SaveTexture(strTextureFileName);
|
||
|
||
m_pd3dDevice->SetTransform(D3DTS_PROJECTION,(D3DMATRIX*)&matOldProjection);
|
||
m_pd3dDevice->SetTransform(D3DTS_VIEW,(D3DMATRIX*)&matOldView);
|
||
|
||
m_pFullSceneEffect->BeginRender(BaseGraphicsLayer::m_ClearColor.c);
|
||
delete pScene;
|
||
pScene = NULL;
|
||
m_bSceneNodeCulling = true;
|
||
MessageBox(NULL,"Save Success","minimap",MB_OK);
|
||
|
||
|
||
}
|
||
if(!GetInView())
|
||
m_WeatherManager.Render(m_pd3dDevice);
|
||
|
||
m_pd3dDevice->GetViewport(&m_pTempViewPort);
|
||
|
||
m_HeightField.Render(m_pd3dDevice);
|
||
|
||
m_pd3dDevice->GetViewport(&m_pTempViewPort);
|
||
//m_CharacterManager.Render(m_pd3dDevice);
|
||
//////////////////////////////////////////////////////Render Env
|
||
|
||
D3DXMATRIX matWorld,matView;
|
||
D3DXMATRIX matInvView;
|
||
|
||
CSceneManager::GetDevice()->GetTransform(D3DTS_WORLD,&matWorld);
|
||
D3DXMatrixIdentity(&matWorld);
|
||
CSceneManager::GetDevice()->GetTransform(D3DTS_VIEW,&matView);
|
||
|
||
D3DXMatrixInverse(&matInvView,NULL,&matView);
|
||
|
||
D3DXVECTOR3 vecViewPos = D3DXVECTOR3(matInvView._41,matInvView._42,matInvView._43);
|
||
|
||
D3DXVECTOR3 vecClipRange[4];
|
||
vecClipRange[0].y = vecClipRange[1].y = vecClipRange[2].y = vecClipRange[3].y = 300.0f;
|
||
vecClipRange[0].x = 15800.0f;
|
||
vecClipRange[0].z = 63000.0f;
|
||
|
||
vecClipRange[1].x = 281000.0f;
|
||
vecClipRange[1].z = 63000.0f;
|
||
|
||
vecClipRange[2].x = 15800.0f;
|
||
vecClipRange[2].z = 292000.0f;
|
||
|
||
vecClipRange[3].x = 281000.0f;
|
||
vecClipRange[3].z = 292000.0f;
|
||
|
||
if((vecClipRange[0].x <= vecViewPos.x) && (vecClipRange[0].z <= vecViewPos.z))
|
||
{
|
||
if((vecClipRange[3].x >= vecViewPos.x) && (vecClipRange[3].z >= vecViewPos.z))
|
||
{
|
||
bRenderEnv = false;
|
||
}
|
||
}
|
||
|
||
if(bRenderEnv) {
|
||
/* CSceneManager::m_pEnvPlaneTex->InitClipRange(vecClipRange[0],
|
||
vecClipRange[1],
|
||
vecClipRange[2],
|
||
vecClipRange[3]);*/
|
||
|
||
vecViewPos.y = 1900.0f;
|
||
CSceneManager::m_pEnvPlaneTex->RenderBegin(vecViewPos,matWorld,1900.0f);
|
||
/*
|
||
CSceneManager::m_WeatherManager.Render(CSceneManager::GetDevice());
|
||
CSceneManager::m_HeightField.Render(CSceneManager::GetDevice());
|
||
|
||
CSceneManager::m_CharacterManager.Render(CSceneManager::GetDevice());
|
||
|
||
CSceneManager::m_pEnvPlaneTex->RenderEnd();*/
|
||
}
|
||
//////////////////////////////////////////////////////////////////////////
|
||
|
||
|
||
//m_HeightField.RenderWater(m_pd3dDevice);
|
||
m_pd3dDevice->GetViewport(&m_pTempViewPort);
|
||
|
||
if(SHADOWSIZE!=0)
|
||
{
|
||
if(strcmp(CRenderOption::m_strBaseGraphicsDataPath, "Zone100"))
|
||
{
|
||
m_CharacterManager.HeightFieldShadowRender(m_pd3dDevice);
|
||
m_CharacterManager.HeightFieldCharacterLightRender(m_pd3dDevice);
|
||
}
|
||
}
|
||
m_InstanceObjectManager.Render(m_pd3dDevice);
|
||
m_CharacterManager.HeightFieldCharacterLightRender(m_pd3dDevice);
|
||
|
||
// <20><><EFBFBD><EFBFBD> :: <20><><EFBFBD>߿<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>m_HeightField.RenderShadow(m_pd3dDevice);
|
||
|
||
m_pd3dDevice->GetViewport(&m_pTempViewPort);
|
||
//m_Boid.Render(m_pd3dDevice);
|
||
if(!GetInView())
|
||
m_HeightField.m_GrassSceneManager.Render(m_pd3dDevice);
|
||
/* m_pd3dDevice->GetViewport(&m_pTempViewPort);
|
||
m_WeatherManager.SecondRender(m_pd3dDevice);
|
||
m_pd3dDevice->GetViewport(&m_pTempViewPort);
|
||
*/
|
||
}
|
||
else
|
||
{
|
||
//m_HeightField.SetObjectCulling(false);
|
||
//m_HeightField.Render(m_pd3dDevice);
|
||
//m_WeatherManager.Render(m_pd3dDevice);
|
||
m_CharacterManager.Render(m_pd3dDevice);
|
||
|
||
}
|
||
/* {
|
||
D3DXMATRIX matOldView;
|
||
D3DXVECTOR3 vecViewPos;
|
||
m_pd3dDevice->GetTransform(D3DTS_VIEW,&matOldView);
|
||
D3DXMatrixInverse(&matOldView,NULL,&matOldView);
|
||
|
||
vecViewPos.x = matOldView._41;
|
||
vecViewPos.y = matOldView._42;
|
||
vecViewPos.z = matOldView._43;
|
||
|
||
vector3 vecToward = m_ViewCamera->GetViewTowardVector();
|
||
|
||
D3DXVECTOR3 vecLine[2];
|
||
vecLine[0].x = vecViewPos.x + 500.0f;
|
||
vecLine[0].y = vecViewPos.y ;
|
||
vecLine[0].z = vecViewPos.z + 500.0f;
|
||
|
||
vecLine[1].x = vecViewPos.x + 500.0f + (vecToward.x) * 1000.0f;
|
||
vecLine[1].y = vecViewPos.y + vecToward.y * 1000.0f;
|
||
vecLine[1].z = vecViewPos.z + 500.0f + vecToward.z * 1000.0f;
|
||
m_pd3dDevice->SetVertexShader(D3DFVF_XYZ);
|
||
m_pd3dDevice->SetPixelShader(NULL);
|
||
|
||
if(CheckRayCollision(vecLine[0],vecLine[1]))
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_TEXTUREFACTOR,0xffff00ff);
|
||
else
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_TEXTUREFACTOR,0xff00ffff);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
|
||
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_LINELIST,1,vecLine,sizeof(D3DXVECTOR3));
|
||
|
||
|
||
}*/
|
||
m_EffectManager.Render();
|
||
m_EffectManager.RenderScript();
|
||
m_HeightField.RenderMapEffect();
|
||
if(!g_CameraScript->ISPlay()) {
|
||
g_CameraScript->RenderPos_Up();
|
||
g_CameraScript->RenderLook();
|
||
g_CameraScript->RenderLine();
|
||
g_CameraScript->RenderPosSpline();
|
||
g_CameraScript->RenderLookSpline();
|
||
}
|
||
// ũ<><C5A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>
|
||
if(m_bSnowFall) {
|
||
m_SnowFall.Render();
|
||
}
|
||
|
||
|
||
if(CRenderOption::m_bRain) {
|
||
|
||
m_pRainParticle->UpdateBuffer();
|
||
m_pRainParticle->Render();
|
||
|
||
/** m_pChristmasParticle->UpdateBuffer();
|
||
m_pChristmasParticle->Render();
|
||
*/
|
||
|
||
|
||
}
|
||
if(m_bChristmas) {
|
||
m_pChristmasParticleManager->Render();
|
||
}
|
||
|
||
//m_EffectManager.RenderWorldScript();
|
||
|
||
if(CRenderOption::m_FullSceneGlare)
|
||
{
|
||
m_LightEffectManager.RenderGlareScene(m_pd3dDevice);
|
||
m_pd3dDevice->GetViewport(&m_pTempViewPort);
|
||
/*
|
||
RenderGlareTexture();
|
||
RenderSpecularGlareTexture();
|
||
RenderFullSceneGlare();
|
||
RenderFullSceneAnti();
|
||
RenderFullSceneTextureEnd();
|
||
*/
|
||
}
|
||
|
||
/**/ if( bRenderEnv && m_pEnvPlaneTex != NULL)
|
||
{
|
||
TLVertex pVertex[8];
|
||
|
||
pVertex[0].v.x=0.0f;
|
||
pVertex[0].tu = 0.0f;
|
||
pVertex[0].tv = 1.0f;
|
||
|
||
pVertex[1].v.x=0.0f;
|
||
pVertex[1].tu = 0.0f;
|
||
pVertex[1].tv = 0.0f;
|
||
|
||
pVertex[2].v.x=150;
|
||
pVertex[2].tu = 1.0f;
|
||
pVertex[2].tv = 1.0f;
|
||
|
||
pVertex[3].v.x=150;
|
||
pVertex[3].tu = 1.0f;
|
||
pVertex[3].tv = 0.0f;
|
||
|
||
pVertex[1].v.y=0.0f;
|
||
pVertex[3].v.y=0.0f;
|
||
pVertex[0].v.y=150;
|
||
pVertex[2].v.y=150;
|
||
|
||
for(int i=0;i<4;i++)
|
||
{
|
||
pVertex[i].w=0.1f;
|
||
pVertex[i].v.z=0.1f;
|
||
pVertex[i].Diffuse.c=0xffffffff;
|
||
pVertex[i].Specular.c=0x0;
|
||
}
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 3, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
m_pd3dDevice->SetTexture(0,m_pEnvPlaneTex->GetTexture());
|
||
m_pd3dDevice->SetTexture(1,NULL);
|
||
m_pd3dDevice->SetTexture(2,NULL);
|
||
m_pd3dDevice->SetTexture(3,NULL);
|
||
|
||
m_pd3dDevice->SetVertexShader(TLVERTEXFVF);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE,TRUE);
|
||
}
|
||
if(m_FullSceneFade.c!=0x0)
|
||
{
|
||
TLVertex pVertex[8];
|
||
|
||
pVertex[0].v.x=0.0f;
|
||
pVertex[1].v.x=0.0f;
|
||
pVertex[2].v.x=BaseGraphicsLayer::m_lScreenSx;
|
||
pVertex[3].v.x=BaseGraphicsLayer::m_lScreenSx;
|
||
|
||
pVertex[1].v.y=0.0f;
|
||
pVertex[3].v.y=0.0f;
|
||
pVertex[0].v.y=BaseGraphicsLayer::m_lScreenSy;
|
||
pVertex[2].v.y=BaseGraphicsLayer::m_lScreenSy;
|
||
|
||
for(int i=0;i<4;i++)
|
||
{
|
||
pVertex[i].w=0.1f;
|
||
pVertex[i].v.z=0.1f;
|
||
pVertex[i].Diffuse.c=m_FullSceneFade.c;
|
||
pVertex[i].Specular.c=0x0;
|
||
}
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,D3DBLEND_ONE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND,D3DBLEND_ONE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
|
||
m_pd3dDevice->SetTexture(0,NULL);
|
||
m_pd3dDevice->SetTexture(1,NULL);
|
||
m_pd3dDevice->SetVertexShader(TLVERTEXFVF);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
}
|
||
m_pFullSceneEffect->EndRender();
|
||
|
||
|
||
m_pFullSceneEffect->Render(0,Viewport.Width,Viewport.Height,false);
|
||
//=================================================
|
||
// Glare Render
|
||
static bool bGlare = false;
|
||
static D3DCOLOR clr;
|
||
static DWORD cA=150;
|
||
static DWORD cR=150;
|
||
static DWORD cG=150;
|
||
static DWORD cB=150;
|
||
static D3DXVECTOR4 w = m_GlareManager->GetBlendWeight( CGlareManager::GLARE_CHARACTER );
|
||
if( KeyPressed('R') ) bGlare = false;
|
||
if( KeyPressed('T') ) bGlare = true;
|
||
if( KeyPressed(('Z')) ) w.x += 0.02f;
|
||
if( KeyPressed(('X')) ) w.x -= 0.02f;
|
||
if( KeyPressed(('C')) ) w.y += 0.02f;
|
||
if( KeyPressed(('V')) ) w.y -= 0.02f;
|
||
if( KeyPressed(('B')) ) w.z += 0.02f;
|
||
if( KeyPressed(('N')) ) w.z -= 0.02f;
|
||
if( KeyPressed(('Y')) ) w.w += 0.02f;
|
||
if( KeyPressed(('U')) ) w.w -= 0.02f;
|
||
if( w.x > 1.0f ) w.x = 1.0f;
|
||
if( w.x < 0.0f ) w.x = 0.0f;
|
||
if( w.y > 1.0f ) w.y = 1.0f;
|
||
if( w.y < 0.0f ) w.y = 0.0f;
|
||
if( w.z > 1.0f ) w.z = 1.0f;
|
||
if( w.z < 0.0f ) w.z = 0.0f;
|
||
if( w.w > 1.0f ) w.w = 1.0f;
|
||
if( w.w < 0.0f ) w.w = 0.0f;
|
||
if( KeyPressed(('9')) ) { cA += 5; cR += 5; cG += 5; cB += 5; };
|
||
if( KeyPressed(('0')) ) { cA -= 5; cR -= 5; cG -= 5; cB -= 5; };
|
||
clr = D3DCOLOR_ARGB(cA,cR,cG,cB);
|
||
if( bGlare )
|
||
{
|
||
|
||
m_GlareManager->SetBlendWeight( CGlareManager::GLARE_FULLSCENE,w );
|
||
|
||
//m_GlareManager->SetBlendWeight( CGlareManager::GLARE_FULLSCENE,D3DXVECTOR4(1.0f,1.0f,1.0f,1.0f) );
|
||
//clr = D3DCOLOR_ARGB(m_WeatherManager.m_InterGlareSkyLower.r,cR,cG,cB);
|
||
|
||
clr = D3DCOLOR_ARGB(m_WeatherManager.m_InterGlareSkyLower.r,
|
||
m_WeatherManager.m_InterGlareSkyUpper.r,
|
||
m_WeatherManager.m_InterGlareSkyUpper.g,
|
||
m_WeatherManager.m_InterGlareSkyUpper.b);
|
||
|
||
|
||
CSceneManager::m_GlareManager->SetColor( CGlareManager::GLARE_FULLSCENE, clr);
|
||
|
||
|
||
|
||
m_GlareManager->SetBlendWeight( CGlareManager::GLARE_CHARACTER,w);//D3DXVECTOR4(0.0f,0.0f,1.0f,0.0f) );
|
||
//m_GlareManager->SetBlendWeight( CGlareManager::GLARE_CHARACTER,D3DXVECTOR4(0.0f,0.0f,1.0f,0.0f) );
|
||
// m_GlareManager->RenderCharacterGlare();
|
||
m_GlareManager->RenderFullSceneGlare();
|
||
|
||
}
|
||
|
||
//==================================================
|
||
|
||
|
||
|
||
|
||
//m_GlareTexture.GenerateMipmap(m_pd3dDevice);
|
||
|
||
|
||
CSceneNode CheckNode;
|
||
|
||
//m_pd3dDevice->EndScene();
|
||
|
||
|
||
/* for(int j=0;j<m_Effect_Map.Effect_Num;j++) {
|
||
CheckNode.m_fRad=100.0f;
|
||
CheckNode.m_AccumulateTM.Translation(m_Effect_Map.m_vecEffectPos[j]);
|
||
|
||
if(CheckNode.isCulling()) {
|
||
*/
|
||
|
||
|
||
// }
|
||
// }
|
||
|
||
//matrix *matViewPosition=GetCamera()->GetMatPosition();
|
||
//m_BspScene.Render(m_pd3dDevice,matViewPosition->GetLoc());
|
||
|
||
|
||
|
||
//m_ParticleManager.Render(m_pd3dDevice);
|
||
|
||
/*
|
||
m_CharacterManager.Render(m_pd3dDevice);
|
||
*/
|
||
//m_GrassScene.Render(m_pd3dDevice);
|
||
//m_CharacterManager.CameraTest(m_pd3dDevice);
|
||
/*
|
||
if(SHADOWSIZE!=0)
|
||
{
|
||
m_CharacterManager.HeightFieldShadowRender(m_pd3dDevice);
|
||
m_CharacterManager.InHouseShadowRender(m_pd3dDevice);
|
||
}
|
||
*/
|
||
|
||
//m_AniObject.Render(m_pd3dDevice);
|
||
|
||
|
||
/*
|
||
matrix mat;
|
||
mat.MakeIdent();
|
||
m_pd3dDevice->SetTransform(D3DTS_WORLD,mat);
|
||
LVertex RayVertex[2];
|
||
RayVertex[0].v=m_vecPickRayStart;
|
||
RayVertex[1].v=m_vecPickRayStart+m_vecPickRayDir*10000.0f;
|
||
|
||
RayVertex[0].diff.c=0xffffffff;
|
||
RayVertex[1].spec.c=0x0;
|
||
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_LINESTRIP,1,RayVertex,sizeof(LVertex));
|
||
|
||
m_pd3dDevice->SetTexture(0,NULL);
|
||
m_pd3dDevice->SetTexture(1,NULL);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
|
||
*/
|
||
//m_ViewCamera->Render(m_pd3dDevice);
|
||
/*
|
||
static matrix matPos,matRot,mat;
|
||
static vector3 vecPos(1467525.0f,7190.0f,697322.0f);
|
||
vecPos+=vector3(-10.0f,0.0f,7.0f);
|
||
matPos.Translation(vecPos);
|
||
matRot.YRotation(3.14f/6.0f);
|
||
mat=matRot*matPos;
|
||
m_pd3dDevice->SetTransform(D3DTS_WORLD,mat);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
m_pShip.Render(m_pd3dDevice);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
*/
|
||
/*
|
||
matPos.Translation(
|
||
mat=matRot*matPos;
|
||
m_pd3dDevice->SetTransform(
|
||
m_pShip.Render(m_pd3dDevice);
|
||
/*
|
||
vector3 vecCharacterPos;
|
||
m_pCharacter->GetPosition(vecCharacterPos.x,vecCharacterPos.y,vecCharacterPos.z);
|
||
List<vector3> CharPoly;
|
||
m_HeightField.GetShadowPoly(vecCharacterPos,CharPoly);
|
||
|
||
TTVertex *pCharVertex=new TTVertex[CharPoly.num];
|
||
WORD *pCharIndices=new WORD[CharPoly.num];
|
||
for(int cIndices=0;cIndices<CharPoly.num;cIndices++)
|
||
{
|
||
pCharVertex[cIndices].v=CharPoly[cIndices];
|
||
pCharVertex[cIndices].diff.c=0xffff0000;
|
||
pCharIndices[cIndices]=cIndices;
|
||
}
|
||
delete [] pCharVertex;
|
||
delete [] pCharIndices;
|
||
// make the character's shadow //
|
||
|
||
//
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
|
||
//m_pd3dDevice->SetTexture(0,m_HeightField.m_SectorScene->m_ObjectShadowTexture.GetTexture());
|
||
//m_pd3dDevice->SetTexture(0,m_HeightField.m_SectorScene->m_SectorShadowTexture.GetTexture());
|
||
m_pd3dDevice->SetTexture(0,m_pShadowTexture.GetTexture());
|
||
m_pd3dDevice->SetTexture(1,NULL);
|
||
/*
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
*/
|
||
//m_ViewCamera->Render(m_pd3dDevice);
|
||
|
||
/////////////////////////////////
|
||
|
||
|
||
//////////////////////////////////
|
||
//m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
|
||
//m_pd3dDevice->SetTexture(0,CSceneManager::m_SpGlareTexture.GetTexture());
|
||
//m_pd3dDevice->SetTexture(0,m_SmoothGlareTexture.GetTexture());
|
||
|
||
|
||
/* m_pFullsceneEffect2->BeginRender(0x00000000);
|
||
m_CharacterManager.Render(m_pd3dDevice);
|
||
m_pFullsceneEffect2->EndRender();*/
|
||
//m_pFullSceneEffect->RenderMulti(m_pFullsceneEffect2);
|
||
|
||
|
||
m_pd3dDevice->GetViewport(&m_pTempViewPort);
|
||
m_WeatherManager.SecondRender(m_pd3dDevice);
|
||
m_pd3dDevice->GetViewport(&m_pTempViewPort);
|
||
|
||
}
|
||
|
||
/*
|
||
void CSceneManager::MouseMove(int dx, int dy)
|
||
{
|
||
switch(m_ViewerMode)
|
||
{
|
||
case 0:
|
||
if(CSceneManager::m_isCollisionDetection)
|
||
{
|
||
CollisionType CT;
|
||
matrix* matOldMat=m_ViewCamera->GetMatPosition();
|
||
vector3 vecOldPos=matOldMat->GetLoc();
|
||
m_ViewCamera->InterfaceFreelook(dx,dy);
|
||
vector3 vecNewPos=matOldMat->GetLoc();
|
||
|
||
vector3 vecVelocity=vecNewPos-vecOldPos;
|
||
vecVelocity.y-=10.0f;
|
||
vecNewPos=m_CollisionDetection.GetPosition(vecOldPos,vecVelocity,CT,false);
|
||
matOldMat->_41=vecNewPos.x;
|
||
matOldMat->_42=vecNewPos.y;
|
||
matOldMat->_43=vecNewPos.z;
|
||
matrix matView;
|
||
matView.Inverse(*matOldMat);
|
||
m_ViewCamera->m_matView=matView;
|
||
m_ViewCamera->MoveFrustum();
|
||
}
|
||
m_ViewCamera->InterfaceFreelook(dx,dy);
|
||
break;
|
||
case 1:
|
||
m_ViewCamera->InterfaceCharlook2(-dx,-dy);
|
||
break;
|
||
case 2:
|
||
m_ViewCamera->InterfaceFreeCamera(-dx,-dy);
|
||
//m_ViewCamera->InterfaceFreelook(dx,dy);
|
||
break;
|
||
}
|
||
/*
|
||
if (m_ViewerMode!=0)
|
||
{
|
||
|
||
}
|
||
else
|
||
{
|
||
if(
|
||
if(CSceneManager::m_isCollisionDetection==false)
|
||
m_ViewCamera->InterfaceFreelook(dx,dy);
|
||
else
|
||
{
|
||
|
||
vector3 vecOldPos=(*m_ViewCamera->GetPosition());
|
||
m_ViewCamera->InterfaceFreelook(dx,dy);
|
||
|
||
|
||
}
|
||
}
|
||
*/
|
||
|
||
//m_ViewCamera->InterfaceCharlook(dx,dy,100.0f);
|
||
/*
|
||
D3DXMATRIX *matPosition=(D3DXMATRIX*)m_ViewCamera->GetMatPosition();
|
||
float fDeltaY=dx/300.0f;
|
||
float fDeltaX=dy/300.0f;
|
||
|
||
D3DXVECTOR3 vecT(0.0f, 0.0f, 0.0f);
|
||
D3DXVECTOR3 vecR(0.0f, 0.0f, 0.0f);
|
||
|
||
D3DXMATRIX matT, matR;
|
||
D3DXQUATERNION qR;
|
||
|
||
if(KeyPressed(VK_SHIFT))
|
||
{
|
||
if(KeyPressed('A') || KeyPressed(VK_NUMPAD1) || KeyPressed(VK_LEFT)) vecT.x -= 341.0f; // Slide Left
|
||
if(KeyPressed('D') || KeyPressed(VK_NUMPAD3) || KeyPressed(VK_RIGHT)) vecT.x += 341.0f; // Slide Right
|
||
if(KeyPressed(VK_DOWN)) vecT.y += 341.0f; // Slide Down
|
||
if(KeyPressed(VK_UP)) vecT.y -= 341.0f; // Slide Up
|
||
if(KeyPressed('W'))
|
||
vecT.z += 341.0f; // Move Forward
|
||
if(KeyPressed('S'))
|
||
vecT.z -= 341.0f; // Move Backward
|
||
}
|
||
else
|
||
{
|
||
if(KeyPressed('A') || KeyPressed(VK_NUMPAD1) || KeyPressed(VK_LEFT)) vecT.x -= 5.0f; // Slide Left
|
||
if(KeyPressed('D') || KeyPressed(VK_NUMPAD3) || KeyPressed(VK_RIGHT)) vecT.x += 5.0f; // Slide Right
|
||
if(KeyPressed(VK_DOWN)) vecT.y += 5.0f; // Slide Down
|
||
if(KeyPressed(VK_UP)) vecT.y -= 5.0f; // Slide Up
|
||
if(KeyPressed('W'))
|
||
vecT.z += 5.0f; // Move Forward
|
||
if(KeyPressed('S'))
|
||
vecT.z -= 5.0f; // Move Backward
|
||
}
|
||
if(KeyPressed('P'))
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_FILLMODE,D3DFILL_WIREFRAME);
|
||
}
|
||
if(KeyPressed('O'))
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_FILLMODE,D3DFILL_SOLID);
|
||
}
|
||
vector3 vecOldPos;
|
||
vecOldPos.x=matPosition->_41;
|
||
vecOldPos.y=matPosition->_42;
|
||
vecOldPos.z=matPosition->_43;
|
||
|
||
D3DXMatrixTranslation(&matT, vecT.x, vecT.y, vecT.z);
|
||
D3DXMatrixMultiply(matPosition, &matT, matPosition);
|
||
if(m_ViewerMode!=0)
|
||
{
|
||
vector3 vecPos;
|
||
vecPos.x=matPosition->_41;
|
||
vecPos.y=matPosition->_42;
|
||
vecPos.z=matPosition->_43;
|
||
vector3 vecDir=vecPos-vecOldPos;
|
||
vecDir.y-=10.0f;
|
||
vecPos=m_CollisionDetection.GetPosition(vecOldPos,vecDir);
|
||
matPosition->_41=vecPos.x;
|
||
matPosition->_42=vecPos.y;
|
||
matPosition->_43=vecPos.z;
|
||
}
|
||
|
||
float fRotationX=m_ViewCamera->GetRotationX();
|
||
float fRotationY=m_ViewCamera->GetRotationY();
|
||
|
||
D3DXQuaternionRotationYawPitchRoll(&qR, 0.0f,-fRotationX ,0.0f);
|
||
D3DXMatrixRotationQuaternion(&matR, &qR);
|
||
D3DXMatrixMultiply(matPosition, &matR, matPosition);
|
||
|
||
fRotationX-=fDeltaX;
|
||
fRotationY-=fDeltaY;
|
||
|
||
D3DXQuaternionRotationYawPitchRoll(&qR,-fDeltaY,fRotationX, 0.0f);
|
||
D3DXMatrixRotationQuaternion(&matR, &qR);
|
||
D3DXMatrixMultiply(matPosition, &matR, matPosition);
|
||
|
||
m_ViewCamera->SetRotaitionX(fRotationX);
|
||
m_ViewCamera->SetRotaitionY(fRotationY);
|
||
|
||
m_ViewCamera->SetVecPosition(vector3(m_ViewCamera->GetMatPosition()->_41,m_ViewCamera->GetMatPosition()->_42,m_ViewCamera->GetMatPosition()->_43));
|
||
|
||
matrix *matPos=m_ViewCamera->GetMatPosition();
|
||
matrix matInv;
|
||
matInv.Inverse(*matPos);
|
||
m_ViewCamera->SetMatView(matInv);
|
||
m_ViewCamera->MoveFrustum();
|
||
*/
|
||
//}
|
||
|
||
void CSceneManager::UpdateScene(float fUpdateFrame)
|
||
{
|
||
|
||
/* if(m_pResourceLoader)
|
||
m_pResourceLoader->Process();
|
||
*/
|
||
//m_WeatherManager.m_CloudScene.Update(m_pd3dDevice,0.0f);
|
||
matrix *matViewPosition=GetCamera()->GetMatPosition();
|
||
vector3 vecViewPos=matViewPosition->GetLoc();
|
||
|
||
|
||
CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();
|
||
vector3 vecCamera = m_ViewCamera->GetViewTowardVector();
|
||
vector3 UpCamera = m_ViewCamera->GetViewUpVector();
|
||
vecCamera.Normalize();
|
||
UpCamera.Normalize();
|
||
|
||
|
||
CSectorSoundMap::GetInstance().UpdateListener( vecCamera.x, vecCamera.y, vecCamera.z
|
||
, UpCamera.x, UpCamera.y, UpCamera.z
|
||
, vecViewPos.x, vecViewPos.y, vecViewPos.z );
|
||
CSoundManager::GetInstance().Update();
|
||
|
||
if(m_isTessellate==1)
|
||
{
|
||
m_HeightField.CheckingNextTerrain();
|
||
bool bTerrainTessellate=false;
|
||
bTerrainTessellate=m_HeightField.CheckingTessellate();
|
||
if(bTerrainTessellate)
|
||
{
|
||
AllObjectCalcLens();
|
||
m_HeightField.RebuildShadowPoly();
|
||
//m_CharacterManager.HeightFiledOnChrFixPos();
|
||
}
|
||
|
||
}
|
||
|
||
/*
|
||
static float WeatherTime=0.0f;
|
||
WeatherTime+=0.001f;
|
||
if(WeatherTime>=24.0f)
|
||
{
|
||
WeatherTime=0.0f;
|
||
}
|
||
m_ParticleManager.Update(fUpdateFrame+1.0f);
|
||
*/
|
||
if(m_pBspScene==NULL && m_PickHouseScene==NULL)
|
||
{
|
||
/*
|
||
static List<vector3> m_vecBspConvertList;
|
||
static List<CHouseObjectScene*> m_pBspConvertList;
|
||
static List<vector3> m_vecFieldConvertList;
|
||
static CHouseObjectScene *m_pBspScene;
|
||
*/
|
||
vector3 vecLens;
|
||
for(int i=0;i<m_vecBspConvertList.num;i++)
|
||
{
|
||
vecLens=m_vecBspConvertList[i]-vecViewPos;
|
||
|
||
if(vecLens.GetLens() <= 500.0f)
|
||
{
|
||
m_pBspScene=m_pBspConvertList[i];
|
||
int cAccBsp=0;
|
||
for(int cBspStartPos=0;cBspStartPos<i+1;cBspStartPos++)
|
||
{
|
||
if(m_pBspConvertList[cBspStartPos]==m_pBspScene)
|
||
cAccBsp++;
|
||
}
|
||
|
||
//m_pBspConvertList[i]
|
||
matrix matToStartPos;
|
||
matToStartPos=m_pBspScene->m_HouseObject->m_pInHouseMap->m_matObjectList[(cAccBsp-1)*4+1]*m_pBspScene->m_AccumulateTM;
|
||
|
||
matViewPosition->_41=matToStartPos._41;
|
||
matViewPosition->_42=matToStartPos._42;
|
||
matViewPosition->_43=matToStartPos._43;
|
||
|
||
m_vecFieldConvertList.num=0;
|
||
|
||
for(int cField=0;cField<m_pBspScene->m_HouseObject->m_pInHouseMap->m_matObjectList.num;cField+=4)
|
||
{
|
||
matToStartPos=m_pBspScene->m_HouseObject->m_pInHouseMap->m_matObjectList[cField+2]*m_pBspScene->m_AccumulateTM;
|
||
m_vecFieldConvertList.Add(matToStartPos.GetLoc());
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else if(m_pBspScene && m_PickHouseScene==NULL )
|
||
{
|
||
vector3 vecLens;
|
||
for(int i=0;i<m_vecFieldConvertList.num;i++)
|
||
{
|
||
vecLens=m_vecFieldConvertList[i]-vecViewPos;
|
||
|
||
if(vecLens.GetLens() <= 500.0f)
|
||
{
|
||
matrix matExitPos=m_pBspScene->m_HouseObject->m_pInHouseMap->m_matObjectList[i*4+3]*m_pBspScene->m_AccumulateTM;
|
||
m_pBspScene=NULL;
|
||
|
||
matViewPosition->_41=matExitPos._41;
|
||
matViewPosition->_42=matExitPos._42;
|
||
matViewPosition->_43=matExitPos._43;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
CSectorScene::m_fCloudMove+=fUpdateFrame*0.0001f;
|
||
CWaterScene::IncWaterTexture(((int)fUpdateFrame)/2.5f);
|
||
|
||
m_WeatherManager.Update((float)((int)fUpdateFrame));
|
||
|
||
m_HeightField.Update((float)((int)fUpdateFrame));
|
||
|
||
m_RBspSceneManager.UpdateBsp();
|
||
|
||
//m_Boid.Update(fUpdateFrame);
|
||
|
||
if(CRenderOption::m_bRain) {
|
||
|
||
D3DXMATRIX matView,matInvView;
|
||
|
||
GetDevice()->GetTransform(D3DTS_VIEW,&matView);
|
||
D3DXMatrixInverse(&matInvView,NULL,&matView);
|
||
D3DXVECTOR3 vecViewPos = D3DXVECTOR3(matInvView._41,matInvView._42,matInvView._43);
|
||
|
||
|
||
m_pRainParticle->CreateRain(vecViewPos.x - 200.0f,vecViewPos.y - 30.0f,vecViewPos.z - 200.0f,
|
||
vecViewPos.x + 200.0f,vecViewPos.y + 200.0f,vecViewPos.z + 200.0f,
|
||
16.5, 200);
|
||
|
||
/*
|
||
if((m_pChristmasParticle->m_bStart) && (m_pChristmasParticle->m_fHeight < 500.0f)) {
|
||
m_pChristmasParticle->m_fHeight+= 20.0f;
|
||
}
|
||
|
||
|
||
|
||
if( KeyPressed('Q') ) {
|
||
|
||
|
||
vector3 vecDir = m_ViewCamera->GetViewTowardVector();
|
||
vecDir.Normalize();
|
||
vector3 vecUp = m_ViewCamera->GetViewUpVector();
|
||
vecUp.Normalize();
|
||
|
||
vector3 vecCross = vecDir ^ vecUp;
|
||
vecCross.Normalize();
|
||
|
||
vecViewPos.x += vecDir.x * 1500.0f;
|
||
vecViewPos.y = m_CharacterManager.m_CharacterList[0].m_vecRealPosition.y + 100;//m_pChristmasParticle->m_fHeight;
|
||
|
||
vecViewPos.z += vecDir.z * 1500.0f;
|
||
|
||
m_pChristmasParticle->m_vecCenter = D3DXVECTOR3(vecViewPos.x,vecViewPos.y,vecViewPos.z);
|
||
m_pChristmasParticle->m_vecRight = D3DXVECTOR3(vecCross.x,vecCross.y,vecCross.z);
|
||
m_pChristmasParticle->m_vecUp = D3DXVECTOR3(vecUp.x,vecUp.y,vecUp.z);
|
||
m_pChristmasParticle->SetStart(true);
|
||
|
||
//m_pChristmasParticle->CreateChristmasParticle(vecViewPos.x,vecViewPos.y,vecViewPos.z,0.0f,350,vecCross.x,vecCross.y,vecCross.z,vecUp.x,vecUp.y,vecUp.z);
|
||
}
|
||
if(m_pChristmasParticle->m_fHeight >= 500.0f) {
|
||
m_pChristmasParticle->SetExtUse(true);
|
||
m_pChristmasParticle->SetStart(false);
|
||
m_pChristmasParticle->SetMaxLife(85.0f);
|
||
|
||
///Sound
|
||
CEffScript *pCristmas = new CEffScript;
|
||
|
||
|
||
int iRand = rand() % 3;
|
||
|
||
switch(iRand) {
|
||
case 0:
|
||
m_pChristmasParticle->SetColor((rand() %100 / 100.0f),0.0f,0.0f,(rand() %100 / 100.0f),0.0f,0.0f);
|
||
pCristmas->GetScriptData("ChristParticleR.esf");
|
||
|
||
break;
|
||
case 1:
|
||
m_pChristmasParticle->SetColor(0.0f,(rand() %100 / 100.0f),0.0f,0.0f,(rand() %100 / 100.0f),0.0f);
|
||
pCristmas->GetScriptData("ChristParticleG.esf");
|
||
break;
|
||
case 2:
|
||
m_pChristmasParticle->SetColor(0.0f,0.0f,(rand() %100 / 100.0f),0.0f,0.0f,(rand() %100 / 100.0f));
|
||
pCristmas->GetScriptData("ChristParticleB.esf");
|
||
break;
|
||
}
|
||
|
||
CSceneManager::AddInterfaceScript(pCristmas);
|
||
vector3 *vecCameraPos = CSceneManager::m_ViewCamera->GetPosition();
|
||
|
||
pCristmas->SetStartPos(vecCameraPos->x,vecCameraPos->y,vecCameraPos->z);
|
||
pCristmas->SetEndPos(vecCameraPos->x,vecCameraPos->y,vecCameraPos->z);
|
||
|
||
pCristmas->SetChr(NULL,NULL);
|
||
pCristmas->SetChrFwd(0.0f,0.0f,1.0f);
|
||
|
||
|
||
|
||
m_pChristmasParticle->CreateChristmasParticle(m_pChristmasParticle->m_vecCenter.x,
|
||
(m_pChristmasParticle->m_vecCenter.y + (m_pChristmasParticle->m_fHeight * 2.0f)),m_pChristmasParticle->m_vecCenter.z,5.0f,850,
|
||
m_pChristmasParticle->m_vecRight.x,m_pChristmasParticle->m_vecRight.y,m_pChristmasParticle->m_vecRight.z,
|
||
m_pChristmasParticle->m_vecUp.x,m_pChristmasParticle->m_vecUp.y,m_pChristmasParticle->m_vecUp.z,true);
|
||
|
||
m_pChristmasParticle->m_fHeight = 0.0f;
|
||
}
|
||
else if(m_pChristmasParticle->m_bStart) {
|
||
m_pChristmasParticle->SetMaxLife(30.0f);
|
||
m_pChristmasParticle->SetColor(1.0f,1.0f,1.0f,1.0f,1.0f,1.0f);
|
||
|
||
m_pChristmasParticle->CreateChristmasParticle(m_pChristmasParticle->m_vecCenter.x,
|
||
(m_pChristmasParticle->m_vecCenter.y + m_pChristmasParticle->m_fHeight),m_pChristmasParticle->m_vecCenter.z,5.0f,10,
|
||
m_pChristmasParticle->m_vecRight.x,m_pChristmasParticle->m_vecRight.y,m_pChristmasParticle->m_vecRight.z,
|
||
m_pChristmasParticle->m_vecUp.x,m_pChristmasParticle->m_vecUp.y,m_pChristmasParticle->m_vecUp.z);
|
||
|
||
}*/
|
||
|
||
}
|
||
if(m_bChristmas) {
|
||
/* static bool bPushed = false;
|
||
if( KeyPressed('Q') && !bPushed) {
|
||
if(CSceneManager::m_CharacterManager.m_CharacterList.num > 0) {
|
||
CChristmasParticle *pChristmasParticle = NULL;
|
||
pChristmasParticle = new CChristmasParticle;
|
||
pChristmasParticle->Init(900,"testparticle1.dds");
|
||
|
||
vector3 vecDir = CSceneManager::m_ViewCamera->GetViewTowardVector();
|
||
vecDir.Normalize();
|
||
|
||
D3DXVECTOR3 vecPos;
|
||
|
||
vecPos.x = CSceneManager::m_CharacterManager.m_CharacterList[0].m_vecRealPosition.x + vecDir.x * 1500.0f;
|
||
vecPos.y = CSceneManager::m_CharacterManager.m_CharacterList[0].m_vecRealPosition.y + 100;//m_pChristmasParticle->m_fHeight;
|
||
|
||
vecPos.z = CSceneManager::m_CharacterManager.m_CharacterList[0].m_vecRealPosition.z + vecDir.z * 1500.0f;
|
||
|
||
|
||
m_pChristmasParticleManager->AddParticle(pChristmasParticle,vecPos.x,vecPos.y,vecPos.z);
|
||
bPushed = true;
|
||
}
|
||
|
||
}
|
||
else {
|
||
bPushed = false;
|
||
}*/
|
||
m_pChristmasParticleManager->ProcessParticle();
|
||
}
|
||
|
||
|
||
int snum = m_EffectManager.GetScriptNum();
|
||
for(int scnt = 0;scnt<snum;scnt++)
|
||
m_EffectManager.ProcessScript(scnt);
|
||
|
||
|
||
|
||
for(int cUpdate=1;cUpdate<fUpdateFrame-1;cUpdate++)
|
||
{
|
||
m_fWeatherTime+=m_fWeatherTimeAdder;
|
||
if(m_fWeatherTime>=24.0f)
|
||
m_fWeatherTime=0.0f;
|
||
}
|
||
m_WeatherManager.SetWeather(m_fWeatherTime,m_pd3dDevice);
|
||
|
||
if(fUpdateFrame>=10.0f)
|
||
return;
|
||
|
||
if(m_ViewerMode==0)
|
||
{
|
||
vector3 vecPos=m_ViewCamera->m_matPosition.GetLoc();
|
||
//CZ3DSound::SetListenerPosition(vecPos);
|
||
//CZ3DSound::SetListenerDirection(CSceneManager::m_ViewCamera->GetRotationY()+3.14159f);
|
||
//CZ3DSound::Process();
|
||
|
||
for(int cUpdate=1;cUpdate<fUpdateFrame-1;cUpdate++)
|
||
{
|
||
m_CharacterManager.ActionProcess();
|
||
|
||
//m_fWeatherTime+=m_fWeatherTimeAdder;
|
||
//if(m_fWeatherTime>=24.0f)
|
||
// m_fWeatherTime=0.0f;
|
||
}
|
||
if(fUpdateFrame>=1)
|
||
m_CharacterManager.UpdateFrame(-1);
|
||
}
|
||
if(m_ViewerMode==1)
|
||
{
|
||
for(int cUpdate=1;cUpdate<fUpdateFrame-1;cUpdate++)
|
||
{
|
||
m_CharacterManager.ActionProcess();
|
||
/*
|
||
m_fWeatherTime+=m_fWeatherTimeAdder;
|
||
if(m_fWeatherTime>=24.0f)
|
||
m_fWeatherTime=0.0f;
|
||
*/
|
||
}
|
||
if(fUpdateFrame>=1)
|
||
m_CharacterManager.UpdateFrame(-1);
|
||
}
|
||
if(m_ViewerMode==2)
|
||
{
|
||
for(int cUpdate=1;cUpdate<fUpdateFrame;cUpdate++)
|
||
{
|
||
m_CharacterManager.ActionProcess();
|
||
/*
|
||
m_fWeatherTime+=m_fWeatherTimeAdder;
|
||
if(m_fWeatherTime>=24.0f)
|
||
m_fWeatherTime=0.0f;
|
||
*/
|
||
}
|
||
}
|
||
|
||
/*
|
||
|
||
vector3 vecPos=CSceneManager::m_ViewCamera->m_matPosition.GetLoc();
|
||
CSectorScene *pSector=PickTerrain(vecPos.x,vecPos.y,vecPos.z);
|
||
if(pSector)
|
||
{
|
||
if(pSector->m_MapWater)
|
||
{
|
||
if(pSector->m_MapWater->m_fWaterHeight>vecPos.y)
|
||
{
|
||
m_WeatherManager.m_InterFogFar=1000.0f;
|
||
m_WeatherManager.m_InterSkyFogFar=1000.0f;
|
||
m_WeatherManager.m_InterFogNear=100.0f;
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
//Landscape effect update
|
||
CSectorScene *tmp_sector = PickTerrain();
|
||
|
||
|
||
|
||
|
||
for(cUpdate=0;cUpdate<(int)fUpdateFrame;cUpdate++)
|
||
{
|
||
//Landscape effect
|
||
if(tmp_sector != NULL) {
|
||
//tmp_sector->UpdateLandscapeEffect();
|
||
tmp_sector->UpdateEffect();
|
||
}
|
||
//effect
|
||
m_EffectManager.UpdateFrame();
|
||
////////////ũ<><C5A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>//
|
||
if(m_bSnowFall) {
|
||
|
||
D3DXMATRIX tmpview;
|
||
m_pd3dDevice->GetTransform(D3DTS_VIEW,&tmpview);
|
||
D3DXMatrixInverse(&tmpview,NULL,&tmpview);
|
||
|
||
vector3 tmppos;
|
||
tmppos.x = tmpview._41;
|
||
tmppos.y = tmpview._42;
|
||
tmppos.z = tmpview._43;
|
||
|
||
vector3 tmptoward = m_ViewCamera->GetViewTowardVector();
|
||
vector3 tmpup = m_ViewCamera->GetViewUpVector();
|
||
tmptoward.Normalize();
|
||
tmpup.Normalize();
|
||
|
||
m_SnowFall.Update(tmppos.x + tmptoward.x * 700.0f,tmppos.y,tmppos.z + tmptoward.z * 700.0f,1000.0f,1000.0f,tmppos.y + 700.0f);
|
||
|
||
//m_SnowFall.Update(tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 100.0f);
|
||
}
|
||
|
||
///////////////////////////////////////////
|
||
|
||
//snum = m_EffectManager.GetWScriptNum();
|
||
/* for(int scnt = 0;scnt<snum;scnt++)
|
||
m_EffectManager.ProcessWScript(scnt);
|
||
*/
|
||
|
||
}
|
||
|
||
/*
|
||
static DWORD ftime = timeGetTime();
|
||
DWORD fFtime = timeGetTime();
|
||
|
||
if((fFtime - ftime) > 20) {
|
||
m_pWaterTexGenerator->Update();
|
||
ftime = fFtime;
|
||
}
|
||
*/
|
||
static bool bq = false;
|
||
if( KeyPressed('Q') )
|
||
{
|
||
if(!bq)
|
||
{
|
||
bq = true;
|
||
CRenderOption::m_CharacterPerPixelLighting = !CRenderOption::m_CharacterPerPixelLighting;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
bq = false;
|
||
}
|
||
|
||
|
||
}
|
||
void CSceneManager::PickNextObject(int iOrder,int PickMode)
|
||
{
|
||
if(PickMode==-1)
|
||
return;
|
||
|
||
if(m_bPickFix)
|
||
{
|
||
return;
|
||
}
|
||
int cObject;
|
||
|
||
if(PickMode==1)
|
||
{
|
||
if(m_pPickSector && m_PickHouseScene)
|
||
{
|
||
|
||
for(cObject=0;cObject<m_pPickSector->m_HouseObjectNode.num;cObject++)
|
||
{
|
||
if(m_PickHouseScene==m_pPickSector->m_HouseObjectNode[cObject])
|
||
{
|
||
if(iOrder == 0)
|
||
{
|
||
if(cObject != m_pPickSector->m_HouseObjectNode.num - 1)
|
||
m_PickHouseScene=m_pPickSector->m_HouseObjectNode[cObject+1];
|
||
else
|
||
m_PickHouseScene=m_pPickSector->m_HouseObjectNode[0];
|
||
}
|
||
else if(iOrder == 1)
|
||
{
|
||
if(cObject != 0)
|
||
m_PickHouseScene=m_pPickSector->m_HouseObjectNode[cObject-1];
|
||
else
|
||
m_PickHouseScene=m_pPickSector->m_HouseObjectNode[m_pPickSector->m_HouseObjectNode.num - 1];
|
||
|
||
}
|
||
break;
|
||
}
|
||
|
||
}
|
||
m_PickObjectScene=NULL;
|
||
}
|
||
}
|
||
else if(PickMode == 2)
|
||
{
|
||
if(m_pPickSector && m_PickObjectScene)
|
||
{
|
||
|
||
for(cObject=0;cObject<m_pPickSector->m_ObjectSceneNode.num;cObject++)
|
||
{
|
||
if(m_PickObjectScene==m_pPickSector->m_ObjectSceneNode[cObject])
|
||
{
|
||
if(iOrder == 0)
|
||
{
|
||
if(cObject != m_pPickSector->m_ObjectSceneNode.num - 1)
|
||
m_PickObjectScene=m_pPickSector->m_ObjectSceneNode[cObject+1];
|
||
else
|
||
m_PickObjectScene=m_pPickSector->m_ObjectSceneNode[0];
|
||
}
|
||
else if(iOrder == 1)
|
||
{
|
||
if(cObject != 0)
|
||
m_PickObjectScene=m_pPickSector->m_ObjectSceneNode[cObject-1];
|
||
else
|
||
m_PickObjectScene=m_pPickSector->m_ObjectSceneNode[m_pPickSector->m_ObjectSceneNode.num - 1];
|
||
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
}
|
||
m_PickHouseScene=NULL;
|
||
}
|
||
}
|
||
|
||
}
|
||
void CSceneManager::PickObject(float fPx, float fPy, float fPz,int PickMode)
|
||
{
|
||
|
||
if(PickMode==-1)
|
||
return;
|
||
|
||
if(m_bPickFix)
|
||
{
|
||
return;
|
||
}
|
||
|
||
float fNearestInterval=LENS_NEAR_OBJECT;
|
||
int ix,iy;
|
||
int cObject;
|
||
// picking pos
|
||
vector3 vecPick(fPx,fPy,fPz);
|
||
vector3 vecLens;
|
||
vector3 vecObjectPos;
|
||
|
||
if(m_pBspScene)
|
||
{
|
||
matrix matLightPos;
|
||
matrix matObjectTM;
|
||
vector3 vecObjectPos;
|
||
for(int cLight=0;cLight<m_pBspScene->m_HouseObject->m_pBspObject->m_EditLightList.num;cLight++)
|
||
{
|
||
float fRad=20.0f;
|
||
matLightPos.Translation(m_pBspScene->m_HouseObject->m_pBspObject->m_EditLightList[cLight].m_vecLightPos);
|
||
|
||
matObjectTM=matLightPos*m_pBspScene->m_AccumulateTM;
|
||
|
||
vecObjectPos=matObjectTM.GetLoc();
|
||
|
||
vector3 vecInter=m_vecPickRayStart-vecObjectPos;
|
||
|
||
float fC=(vecInter*vecInter)-fRad;
|
||
float fB=m_vecPickRayDir*(m_vecPickRayStart-vecObjectPos);
|
||
|
||
vecObjectPos=m_vecPickRayStart-vecObjectPos;
|
||
|
||
if(fB*fB-fC>=0.0f)
|
||
{
|
||
if(vecObjectPos.GetLens() <= fNearestInterval)
|
||
{
|
||
if(PickMode==2)
|
||
{
|
||
m_pBspScene->m_HouseObject->m_pBspObject->m_SelectLight=cLight;
|
||
fNearestInterval=vecObjectPos.GetLens();
|
||
/*
|
||
m_PickLightScene=m_PickHouseScene->m_HouseObject->m_LightList[cLight];
|
||
m_PickObjectScene=NULL;
|
||
fNearestInterval=vecObjectPos.GetLens();
|
||
*/
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
return;
|
||
}
|
||
/* if(PickMode == 7) {
|
||
fNearestInterval=LENS_NEAR_OBJECT;
|
||
for(int i=0;i<m_EffectNum;i++) {
|
||
|
||
CX3DEffect *PickEffect = m_EffectManager.m_lstEffect[i];
|
||
|
||
vector3 *vecTargetObjectPos = PickEffect->GetCenter();
|
||
vecLens= (*vecTargetObjectPos) - vecPick;
|
||
|
||
if( vecLens.GetLens() <= fNearestInterval)
|
||
{
|
||
m_PickEffect = m_EffectManager.m_lstEffect[i];
|
||
m_PickHouseScene=NULL;
|
||
fNearestInterval=vecLens.GetLens();
|
||
m_bPickEffect = TRUE;
|
||
}
|
||
}
|
||
if(fNearestInterval!=LENS_NEAR_OBJECT)
|
||
return;
|
||
}//PickMode == 7*/
|
||
if(m_PickHouseScene)
|
||
{
|
||
fNearestInterval=LENS_NEAR_OBJECT;
|
||
matrix matInvTM,matTM;
|
||
matTM.Translation(vector3(fPx,fPy,fPz));
|
||
matInvTM.Inverse(m_PickHouseScene->m_AccumulateTM);
|
||
matTM=matTM*matInvTM;
|
||
vector3 vecPickPos=matTM.GetLoc();
|
||
|
||
matrix matObjectTM;
|
||
|
||
for(int cLight=0;cLight<m_PickHouseScene->m_HouseObject->m_LightList.num;cLight++)
|
||
{
|
||
//vecObjectPos=m_PickHouseScene->m_HouseObject->m_LightList[cLight]->m_TM.GetLoc();
|
||
float fRad=m_PickHouseScene->m_HouseObject->m_LightList[cLight]->m_fRad;
|
||
matObjectTM=m_PickHouseScene->m_HouseObject->m_LightList[cLight]->m_TM*m_PickHouseScene->m_AccumulateTM;
|
||
fRad=m_PickHouseScene->m_HouseObject->m_LightList[cLight]->m_fRad;
|
||
vecObjectPos=matObjectTM.GetLoc();
|
||
|
||
vector3 vecInter=m_vecPickRayStart-vecObjectPos;
|
||
|
||
float fC=(vecInter*vecInter)-fRad;
|
||
float fB=m_vecPickRayDir*(m_vecPickRayStart-vecObjectPos);
|
||
|
||
vecObjectPos=m_vecPickRayStart-vecObjectPos;
|
||
|
||
if(fB*fB-fC>=0.0f)
|
||
{
|
||
if(vecObjectPos.GetLens() <= fNearestInterval)
|
||
{
|
||
if(PickMode==2)
|
||
{
|
||
m_PickLightScene=m_PickHouseScene->m_HouseObject->m_LightList[cLight];
|
||
m_PickObjectScene=NULL;
|
||
fNearestInterval=vecObjectPos.GetLens();
|
||
}
|
||
}
|
||
}
|
||
//vecObjectPos=vecPickPos-vecObjectPos;
|
||
/*
|
||
if(vecObjectPos.GetLens() <= fNearestInterval)
|
||
{
|
||
if(PickMode==2)
|
||
{
|
||
m_PickLightScene=m_PickHouseScene->m_HouseObject->m_LightList[cLight];
|
||
m_PickObjectScene=NULL;
|
||
fNearestInterval=vecObjectPos.GetLens();
|
||
}
|
||
}
|
||
*/
|
||
}
|
||
|
||
for(int cObject=0;cObject<m_PickHouseScene->m_HouseObject->m_ObjectList.num;cObject++)
|
||
{
|
||
float fRad=m_PickHouseScene->m_HouseObject->m_ObjectList[cObject]->m_fRad;
|
||
matObjectTM=m_PickHouseScene->m_HouseObject->m_ObjectList[cObject]->m_TM*m_PickHouseScene->m_AccumulateTM;
|
||
fRad=m_PickHouseScene->m_HouseObject->m_ObjectList[cObject]->m_fRad;
|
||
vecObjectPos=matObjectTM.GetLoc();
|
||
|
||
vector3 vecInter=m_vecPickRayStart-vecObjectPos;
|
||
|
||
float fC=(vecInter*vecInter)-fRad;
|
||
float fB=m_vecPickRayDir*(m_vecPickRayStart-vecObjectPos);
|
||
|
||
vecObjectPos=m_vecPickRayStart-vecObjectPos;
|
||
|
||
if(fB*fB-fC>=0.0f)
|
||
{
|
||
if(vecObjectPos.GetLens() <= fNearestInterval)
|
||
{
|
||
if(PickMode==2)
|
||
{
|
||
m_PickObjectScene=m_PickHouseScene->m_HouseObject->m_ObjectList[cObject];
|
||
m_PickLightScene=NULL;
|
||
fNearestInterval=vecObjectPos.GetLens();
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
vecObjectPos=m_PickHouseScene->m_HouseObject->m_ObjectList[cObject]->m_TM.GetLoc();
|
||
vecObjectPos=vecPickPos-vecObjectPos;
|
||
if(vecObjectPos.GetLens() <= fNearestInterval)
|
||
{
|
||
if(PickMode==2)
|
||
{
|
||
m_PickObjectScene=m_PickHouseScene->m_HouseObject->m_ObjectList[cObject];
|
||
m_PickLightScene=NULL;
|
||
fNearestInterval=vecObjectPos.GetLens();
|
||
}
|
||
}
|
||
*/
|
||
}
|
||
if(fNearestInterval!=LENS_NEAR_OBJECT)
|
||
return;
|
||
if(PickMode==2)
|
||
return;
|
||
}
|
||
fNearestInterval=LENS_NEAR_HOUSE;
|
||
|
||
for(ix=0;ix<m_HeightField.GetLSizeX();ix++)
|
||
{
|
||
for(iy=0;iy<m_HeightField.GetLSizeY();iy++)
|
||
{ //picking point<6E><74> sector <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>˻<EFBFBD>
|
||
if( m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_TM._41 <= fPx &&
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_TM._41+SECTORSIZE > fPx &&
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_TM._43 <= fPz &&
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_TM._43+SECTORSIZE > fPz)
|
||
{ //<2F><><EFBFBD><EFBFBD>
|
||
if(PickMode==1)
|
||
{ //house list Ž<><C5BD>
|
||
for(cObject=0;cObject<m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_HouseObjectNode.num;cObject++)
|
||
{
|
||
vector3 vecTargetObjectPos(
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_HouseObjectNode[cObject]->m_AccumulateTM._41,
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_HouseObjectNode[cObject]->m_AccumulateTM._42,
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_HouseObjectNode[cObject]->m_AccumulateTM._43);
|
||
vecLens=vecTargetObjectPos-vecPick;
|
||
if( vecLens.GetLens() <= fNearestInterval)
|
||
{ // <20>ش<EFBFBD><D8B4>ϴ<EFBFBD> house m_PickHouseScene<6E><65><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
m_PickHouseScene=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_HouseObjectNode[cObject];
|
||
m_pPickSector = &(m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()]);
|
||
|
||
m_PickObjectScene=NULL;
|
||
fNearestInterval=vecLens.GetLens();
|
||
}
|
||
}
|
||
if(fNearestInterval!=LENS_NEAR_HOUSE)
|
||
return;
|
||
}
|
||
if(PickMode==2)
|
||
{
|
||
fNearestInterval=LENS_NEAR_OBJECT;
|
||
for(cObject=0;cObject<m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_ObjectSceneNode.num;cObject++)
|
||
{
|
||
vector3 vecTargetObjectPos(
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_ObjectSceneNode[cObject]->m_TM._41,
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_ObjectSceneNode[cObject]->m_TM._42,
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_ObjectSceneNode[cObject]->m_TM._43);
|
||
vecLens=vecTargetObjectPos-vecPick;
|
||
if( vecLens.GetLens() <= fNearestInterval)
|
||
{
|
||
m_PickObjectScene=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_ObjectSceneNode[cObject];
|
||
m_PickHouseScene=NULL;
|
||
m_pPickSector = &(m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()]);
|
||
|
||
fNearestInterval=vecLens.GetLens();
|
||
}
|
||
}
|
||
// object<63><74> picking<6E>Ǿ<EFBFBD><C7BE>ٸ<EFBFBD> sound object <20><><EFBFBD><EFBFBD> üũ
|
||
if( m_PickObjectScene )
|
||
{
|
||
if( strcmp( m_PickObjectScene->m_strObjectName, "Sound.R3S" ) == 0 )
|
||
{
|
||
CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();
|
||
vector3 loc = m_PickObjectScene->m_TM.GetLoc();
|
||
sndMap.PickAmbience( loc.x, loc.y, loc.z );
|
||
}
|
||
|
||
if( strcmp( m_PickObjectScene->m_strObjectName, "Cube.R3S" ) == 0 )
|
||
{
|
||
CBGMController & BGMC = CBGMController::GetInstance();
|
||
vector3 loc = m_PickObjectScene->m_TM.GetLoc();
|
||
BGMC.SelectClosestPoint( loc.x, loc.y, loc.z, 10.0f );
|
||
}
|
||
}
|
||
|
||
|
||
if(fNearestInterval!=LENS_NEAR_OBJECT)
|
||
return;
|
||
}
|
||
/*if(PickMode == 7) {
|
||
fNearestInterval=LENS_NEAR_OBJECT;
|
||
for(int i=0;i<m_EffectNum;i++) {
|
||
|
||
CX3DEffect *PickEffect = m_EffectManager.m_lstEffect[i];
|
||
|
||
vector3 *vecTargetObjectPos = PickEffect->GetCenter();
|
||
vecLens= (*vecTargetObjectPos) - vecPick;
|
||
|
||
if( vecLens.GetLens() <= fNearestInterval)
|
||
{
|
||
m_PickEffect = m_EffectManager.m_lstEffect[i];
|
||
m_PickHouseScene=NULL;
|
||
fNearestInterval=vecLens.GetLens();
|
||
m_bPickEffect = TRUE;
|
||
}
|
||
}
|
||
if(fNearestInterval!=LENS_NEAR_OBJECT)
|
||
return;
|
||
}//PickMode == 7*/
|
||
}
|
||
}
|
||
}
|
||
|
||
//m_PickEffect = NULL;
|
||
m_PickHouseScene=NULL;
|
||
m_PickLightScene=NULL;
|
||
m_PickObjectScene=NULL;
|
||
m_pPickSector = NULL;
|
||
}
|
||
void CSceneManager::PickObjectMove(float fMx, float fMy, float fMz,float fAngle,float fAddy,int MoveMode)
|
||
{
|
||
if(m_PickLightScene)
|
||
{
|
||
CInHouseObjectMap *InHouseMap=m_MapStorage.FindInHouseMap(m_PickHouseScene->m_strOutName,
|
||
m_PickHouseScene->m_strMedName,
|
||
m_PickHouseScene->m_strInName,
|
||
m_PickHouseScene->m_strBSPName);
|
||
if(InHouseMap==NULL)
|
||
return;
|
||
/*
|
||
if(MoveMode==1)
|
||
{
|
||
matrix AddAngleY;
|
||
AddAngleY.YRotation(fAngle);
|
||
m_PickLightScene->m_TM=AddAngleY*m_PickLightScene->m_TM;
|
||
|
||
for(int cLight=0;cLight<InHouseMap->m_LightID.num;cLight++)
|
||
{
|
||
if(m_PickLightScene->m_LightID==InHouseMap->m_LightID[cLight])
|
||
{
|
||
InHouseMap->m_matLightList[cLight]=m_PickLightScene->m_TM;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
if(MoveMode==2)
|
||
{
|
||
m_PickLightScene->m_TM._42+=fAddy;
|
||
for(int cLight=0;cLight<InHouseMap->m_LightID.num;cLight++)
|
||
{
|
||
if(m_PickLightScene->m_LightID==InHouseMap->m_LightID[cLight])
|
||
{
|
||
InHouseMap->m_matLightList[cLight]=m_PickLightScene->m_TM;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
*/
|
||
if(MoveMode==3)
|
||
{
|
||
if(KeyPressed(VK_LEFT)) m_PickLightScene->m_TM._41+=1.0f;
|
||
if(KeyPressed(VK_RIGHT)) m_PickLightScene->m_TM._41-=1.0f;
|
||
if(KeyPressed(VK_UP)) m_PickLightScene->m_TM._43+=1.0f;
|
||
if(KeyPressed(VK_DOWN)) m_PickLightScene->m_TM._43-=1.0f;
|
||
if(KeyPressed(VK_INSERT)) m_PickLightScene->m_TM._42+=1.0f;
|
||
if(KeyPressed(VK_DELETE)) m_PickLightScene->m_TM._42-=1.0f;
|
||
|
||
for(int cLight=0;cLight<InHouseMap->m_LightID.num;cLight++)
|
||
{
|
||
if(m_PickLightScene->m_LightID==InHouseMap->m_LightID[cLight])
|
||
{
|
||
InHouseMap->m_matLightList[cLight]=m_PickLightScene->m_TM;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
/*
|
||
matrix matTM,matInvTM;
|
||
matTM.Translation(vector3(fMx,fMy,fMz));
|
||
matInvTM.Inverse(m_PickHouseScene->m_AccumulateTM);
|
||
|
||
matTM=matTM*matInvTM;
|
||
m_PickLightScene->m_TM._41=matTM._41;
|
||
m_PickLightScene->m_TM._42=matTM._42;
|
||
m_PickLightScene->m_TM._43=matTM._43;
|
||
m_bIsPickObjectMoving=MOVE_LIGHT;
|
||
|
||
for(int cLight=0;cLight<InHouseMap->m_LightID.num;cLight++)
|
||
{
|
||
if(m_PickLightScene->m_LightID==InHouseMap->m_LightID[cLight])
|
||
{
|
||
InHouseMap->m_matLightList[cLight]=m_PickLightScene->m_TM;
|
||
}
|
||
}
|
||
*/
|
||
return;
|
||
}
|
||
if(m_PickObjectScene)
|
||
{
|
||
if(m_PickHouseScene)
|
||
{
|
||
CInHouseObjectMap *InHouseMap=m_MapStorage.FindInHouseMap(m_PickHouseScene->m_strOutName,
|
||
m_PickHouseScene->m_strMedName,
|
||
m_PickHouseScene->m_strInName,
|
||
m_PickHouseScene->m_strBSPName);
|
||
if(InHouseMap==NULL)
|
||
return;
|
||
|
||
if(MoveMode==1)
|
||
{
|
||
matrix AddAngleY;
|
||
AddAngleY.YRotation(fAngle);
|
||
|
||
if(KeyPressed(VK_LEFT)) fAngle=0.2f;
|
||
if(KeyPressed(VK_RIGHT)) fAngle=-0.2f;
|
||
|
||
m_PickObjectScene->m_TM=AddAngleY*m_PickObjectScene->m_TM;
|
||
|
||
for(int cObject=0;cObject<InHouseMap->m_ObjectID.num;cObject++)
|
||
{
|
||
if(m_PickObjectScene->m_ObjectID==InHouseMap->m_ObjectID[cObject])
|
||
{
|
||
InHouseMap->m_matObjectList[cObject]=m_PickObjectScene->m_TM;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
/*
|
||
if(MoveMode==2)
|
||
{
|
||
m_PickObjectScene->m_TM._42+=fAddy;
|
||
|
||
for(int cObject=0;cObject<InHouseMap->m_ObjectID.num;cObject++)
|
||
{
|
||
if(m_PickObjectScene->m_ObjectID==InHouseMap->m_ObjectID[cObject])
|
||
{
|
||
InHouseMap->m_matObjectList[cObject]=m_PickObjectScene->m_TM;
|
||
}
|
||
}
|
||
|
||
return;
|
||
}
|
||
*/
|
||
if(MoveMode==3)
|
||
{
|
||
if(KeyPressed(VK_LEFT)) m_PickObjectScene->m_TM._41+=1.0f;
|
||
if(KeyPressed(VK_RIGHT)) m_PickObjectScene->m_TM._41-=1.0f;
|
||
if(KeyPressed(VK_UP)) m_PickObjectScene->m_TM._43+=1.0f;
|
||
if(KeyPressed(VK_DOWN)) m_PickObjectScene->m_TM._43-=1.0f;
|
||
if(KeyPressed(VK_INSERT)) m_PickObjectScene->m_TM._42+=1.0f;
|
||
if(KeyPressed(VK_DELETE)) m_PickObjectScene->m_TM._42-=1.0f;
|
||
|
||
|
||
for(int cObject=0;cObject<InHouseMap->m_ObjectID.num;cObject++)
|
||
{
|
||
if(m_PickObjectScene->m_ObjectID==InHouseMap->m_ObjectID[cObject])
|
||
{
|
||
InHouseMap->m_matObjectList[cObject]=m_PickObjectScene->m_TM;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
/*
|
||
matrix matTM,matInvTM;
|
||
matTM.Translation(vector3(fMx,fMy,fMz));
|
||
matInvTM.Inverse(m_PickHouseScene->m_AccumulateTM);
|
||
matTM=matTM*matInvTM;
|
||
m_bIsPickObjectMoving=MOVE_OBJECT;
|
||
m_PickObjectScene->m_TM._41=matTM._41;
|
||
m_PickObjectScene->m_TM._42=matTM._42;
|
||
m_PickObjectScene->m_TM._43=matTM._43;
|
||
|
||
|
||
for(int cObject=0;cObject<InHouseMap->m_ObjectID.num;cObject++)
|
||
{
|
||
if(m_PickObjectScene->m_ObjectID==InHouseMap->m_ObjectID[cObject])
|
||
{
|
||
InHouseMap->m_matObjectList[cObject]=m_PickObjectScene->m_TM;
|
||
}
|
||
}
|
||
*/
|
||
return;
|
||
}
|
||
/* else if(m_bPickEffect)
|
||
{
|
||
if(m_PickEffect == NULL)
|
||
return;
|
||
|
||
/* if(MoveMode == 3)
|
||
{
|
||
|
||
CMainFrame *mf=(CMainFrame*)AfxGetApp()->m_pMainWnd;
|
||
CWorldCreatorView *av=(CWorldCreatorView *)mf->GetActiveView();
|
||
|
||
PickMakeRay(point.x,point.y,m_BaseGraphicLayer.m_lScreenSx,m_BaseGraphicLayer.m_lScreenSy);
|
||
vector3 vecPos=m_SceneManager->PickPointTerrain();
|
||
}
|
||
|
||
}*/
|
||
else
|
||
{
|
||
if(m_RBspSceneManager.m_pCurrentBspScene != NULL)
|
||
{
|
||
RBspScene::RBspR3S *pPick = NULL;
|
||
vector3 vecR3SObject = vector3(m_PickObjectScene->m_TM._41,
|
||
m_PickObjectScene->m_TM._42,
|
||
m_PickObjectScene->m_TM._43);
|
||
|
||
int iLeaf = m_RBspSceneManager.m_pCurrentBspScene->FindWorldLeaf(D3DXVECTOR3(vecR3SObject.x,vecR3SObject.y,vecR3SObject.z));
|
||
pPick = m_RBspSceneManager.m_pCurrentBspScene->m_pLeafExs[iLeaf].m_pPickR3SObject;
|
||
|
||
if(m_PickObjectScene != NULL && pPick != NULL)
|
||
{
|
||
|
||
if(MoveMode==1)
|
||
{
|
||
matrix AddAngleY;
|
||
AddAngleY.YRotation(fAngle);
|
||
m_PickObjectScene->m_TM=AddAngleY*m_PickObjectScene->m_TM;
|
||
//x<><78> ȸ<><C8B8>
|
||
if(KeyPressed('7'))
|
||
{
|
||
matrix AddAngleX;
|
||
AddAngleX.XRotation(0.05f);
|
||
m_PickObjectScene->m_TM=AddAngleX*m_PickObjectScene->m_TM;
|
||
}
|
||
if(KeyPressed('8'))
|
||
{
|
||
matrix AddAngleX;
|
||
AddAngleX.XRotation(-0.05f);
|
||
m_PickObjectScene->m_TM=AddAngleX*m_PickObjectScene->m_TM;
|
||
}
|
||
//z<><7A> ȸ<><C8B8>
|
||
if(KeyPressed('9'))
|
||
{
|
||
matrix AddAngleZ;
|
||
AddAngleZ.ZRotation(0.05f);
|
||
m_PickObjectScene->m_TM=AddAngleZ*m_PickObjectScene->m_TM;
|
||
}
|
||
if(KeyPressed('0'))
|
||
{
|
||
matrix AddAngleZ;
|
||
AddAngleZ.ZRotation(-0.05f);
|
||
m_PickObjectScene->m_TM=AddAngleZ*m_PickObjectScene->m_TM;
|
||
}
|
||
// ȸ<><C8B8> <20><><EFBFBD>º<EFBFBD><C2BA><EFBFBD>
|
||
if(KeyPressed('1'))
|
||
{
|
||
matrix AddAngle;
|
||
AddAngle.MakeIdent();
|
||
AddAngle._41=m_PickObjectScene->m_TM._41;
|
||
AddAngle._42=m_PickObjectScene->m_TM._42;
|
||
AddAngle._43=m_PickObjectScene->m_TM._43;
|
||
m_PickObjectScene->m_TM=AddAngle;
|
||
}
|
||
|
||
pPick->m_matTm = m_PickObjectScene->m_TM;
|
||
|
||
m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
|
||
CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->GenerateR3SObject();
|
||
return;
|
||
}//<2F><><EFBFBD><EFBFBD> <20>̵<EFBFBD>
|
||
if(MoveMode==2)
|
||
{
|
||
m_PickObjectScene->m_TM._42+=fAddy;
|
||
pPick->m_matTm = m_PickObjectScene->m_TM;
|
||
|
||
pPick->m_vecPos.x = pPick->m_matTm._41;
|
||
pPick->m_vecPos.y = pPick->m_matTm._42;
|
||
pPick->m_vecPos.z = pPick->m_matTm._43;
|
||
|
||
m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
|
||
CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->GenerateR3SObject();
|
||
return;
|
||
}// x-z<><7A> <20>̵<EFBFBD>
|
||
if(MoveMode==3)
|
||
{
|
||
if(KeyPressed(VK_LEFT)) m_PickObjectScene->m_TM._41+=1.0f;
|
||
if(KeyPressed(VK_RIGHT)) m_PickObjectScene->m_TM._41-=1.0f;
|
||
if(KeyPressed(VK_UP)) m_PickObjectScene->m_TM._43+=1.0f;
|
||
if(KeyPressed(VK_DOWN)) m_PickObjectScene->m_TM._43-=1.0f;
|
||
|
||
pPick->m_matTm = m_PickObjectScene->m_TM;
|
||
|
||
pPick->m_vecPos.x = pPick->m_matTm._41;
|
||
pPick->m_vecPos.y = pPick->m_matTm._42;
|
||
pPick->m_vecPos.z = pPick->m_matTm._43;
|
||
|
||
m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
|
||
CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->GenerateR3SObject();
|
||
return;
|
||
}
|
||
///////
|
||
matrix matTM,matInvTM;
|
||
|
||
|
||
vector3 *vec3Camera = m_ViewCamera->GetPosition();
|
||
D3DXVECTOR3 vecBspStart = D3DXVECTOR3(vec3Camera->x,vec3Camera->y,vec3Camera->z);
|
||
D3DXVECTOR3 vecBspEnd = D3DXVECTOR3(fMx,fMy,fMz);
|
||
// axis <20><>ȯ
|
||
D3DXVECTOR3 vecPos = vecBspStart;
|
||
D3DXMATRIX matTmp;
|
||
D3DXMATRIX matInv;
|
||
|
||
D3DXMatrixIdentity(&matTmp);
|
||
|
||
matTmp._41 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x;
|
||
matTmp._42 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y;
|
||
matTmp._43 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z;
|
||
D3DXMatrixInverse(&matInv,NULL,&matTmp);
|
||
D3DXMatrixIdentity(&matTmp);
|
||
matTmp._41 = vecPos.x;
|
||
matTmp._42 = vecPos.y;
|
||
matTmp._43 = vecPos.z;
|
||
D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
|
||
vecPos.x = matTmp._41;
|
||
vecPos.y = matTmp._42;
|
||
vecPos.z = matTmp._43;
|
||
vecBspStart = vecPos;
|
||
|
||
////
|
||
vecPos = vecBspEnd;
|
||
D3DXMatrixIdentity(&matTmp);
|
||
matTmp._41 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x;
|
||
matTmp._42 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y;
|
||
matTmp._43 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z;
|
||
|
||
D3DXMatrixInverse(&matInv,NULL,&matTmp);
|
||
D3DXMatrixIdentity(&matTmp);
|
||
matTmp._41 = vecPos.x;
|
||
matTmp._42 = vecPos.y;
|
||
matTmp._43 = vecPos.z;
|
||
D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
|
||
vecPos.x = matTmp._41;
|
||
vecPos.y = matTmp._42;
|
||
vecPos.z = matTmp._43;
|
||
vecBspEnd = vecPos;
|
||
///
|
||
/// collision check
|
||
D3DXVECTOR3 vecBspLast = m_RBspSceneManager.m_pCurrentBspScene->CollisionPoint(vecBspStart,vecBspEnd,5.0f);
|
||
/// world axis <20><> <20><>ȯ
|
||
vecPos = vecBspLast;
|
||
D3DXMatrixIdentity(&matTmp);
|
||
matTmp._41 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x;
|
||
matTmp._42 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y;
|
||
matTmp._43 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z;
|
||
matInv = matTmp;
|
||
D3DXMatrixIdentity(&matTmp);
|
||
matTmp._41 = vecPos.x;
|
||
matTmp._42 = vecPos.y;
|
||
matTmp._43 = vecPos.z;
|
||
D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
|
||
vecPos.x = matTmp._41;
|
||
vecPos.y = matTmp._42;
|
||
vecPos.z = matTmp._43;
|
||
vecBspLast = vecPos;
|
||
|
||
///////
|
||
if(vecBspLast.y <= m_PickObjectScene->m_TM._42)
|
||
matTM.Translation(vector3(vecBspLast.x,m_PickObjectScene->m_TM._42,vecBspLast.z));
|
||
else
|
||
matTM.Translation(vector3(vecBspLast.x,vecBspLast.y,vecBspLast.z));
|
||
|
||
m_bIsPickObjectMoving=MOVE_OBJECT;
|
||
|
||
m_PickObjectScene->m_TM._41=matTM._41;
|
||
m_PickObjectScene->m_TM._42=matTM._42;
|
||
m_PickObjectScene->m_TM._43=matTM._43;
|
||
|
||
/////
|
||
pPick->m_matTm = m_PickObjectScene->m_TM;
|
||
|
||
pPick->m_vecPos.x = pPick->m_matTm._41;
|
||
pPick->m_vecPos.y = pPick->m_matTm._42;
|
||
pPick->m_vecPos.z = pPick->m_matTm._43;
|
||
|
||
|
||
m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
|
||
CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->GenerateR3SObject();
|
||
|
||
return;
|
||
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
// object mesh informain <20>б<EFBFBD>
|
||
CSectorMeshMap *pMapMesh=m_MapStorage.FindMeshMap(m_PickObjectScene->m_TM._41,m_PickObjectScene->m_TM._43);
|
||
if(pMapMesh==NULL)
|
||
return;
|
||
/*
|
||
int nIndex=-1;
|
||
CSectorSoundMap *pSoundMap=NULL;
|
||
if(strcmp(m_PickObjectScene->m_strObjectName,"Sound.R3S")==0)
|
||
{
|
||
pSoundMap=m_MapStorage.FindSoundMap(m_PickObjectScene->m_TM._41,m_PickObjectScene->m_TM._43);
|
||
float fLens=10.0f;
|
||
vector3 vecLens;
|
||
for(int i=0;i<pSoundMap->m_SoundPosList.num;i++)
|
||
{
|
||
vecLens=m_PickObjectScene->m_TM.GetLoc()-pSoundMap->m_SoundPosList[i];
|
||
if(fLens>=vecLens.GetLens())
|
||
{
|
||
fLens=vecLens.GetLens();
|
||
nIndex=i;
|
||
}
|
||
}
|
||
if(nIndex==-1)
|
||
return;
|
||
}
|
||
*/
|
||
//y<><79> ȸ<><C8B8>
|
||
if(MoveMode==1)
|
||
{
|
||
matrix AddAngleY;
|
||
AddAngleY.YRotation(fAngle);
|
||
m_PickObjectScene->m_TM=AddAngleY*m_PickObjectScene->m_TM;
|
||
//x<><78> ȸ<><C8B8>
|
||
if(KeyPressed('7'))
|
||
{
|
||
matrix AddAngleX;
|
||
AddAngleX.XRotation(0.05f);
|
||
m_PickObjectScene->m_TM=AddAngleX*m_PickObjectScene->m_TM;
|
||
}
|
||
if(KeyPressed('8'))
|
||
{
|
||
matrix AddAngleX;
|
||
AddAngleX.XRotation(-0.05f);
|
||
m_PickObjectScene->m_TM=AddAngleX*m_PickObjectScene->m_TM;
|
||
}
|
||
//z<><7A> ȸ<><C8B8>
|
||
if(KeyPressed('9'))
|
||
{
|
||
matrix AddAngleZ;
|
||
AddAngleZ.ZRotation(0.05f);
|
||
m_PickObjectScene->m_TM=AddAngleZ*m_PickObjectScene->m_TM;
|
||
}
|
||
if(KeyPressed('0'))
|
||
{
|
||
matrix AddAngleZ;
|
||
AddAngleZ.ZRotation(-0.05f);
|
||
m_PickObjectScene->m_TM=AddAngleZ*m_PickObjectScene->m_TM;
|
||
}
|
||
// ȸ<><C8B8> <20><><EFBFBD>º<EFBFBD><C2BA><EFBFBD>
|
||
if(KeyPressed('1'))
|
||
{
|
||
matrix AddAngle;
|
||
AddAngle.MakeIdent();
|
||
AddAngle._41=m_PickObjectScene->m_TM._41;
|
||
AddAngle._42=m_PickObjectScene->m_TM._42;
|
||
AddAngle._43=m_PickObjectScene->m_TM._43;
|
||
m_PickObjectScene->m_TM=AddAngle;
|
||
}
|
||
|
||
for(int cObject=0;cObject<pMapMesh->m_ObjectSceneID.num;cObject++)
|
||
{
|
||
if(pMapMesh->m_ObjectSceneID[cObject]==m_PickObjectScene->m_ObjectID)
|
||
{
|
||
pMapMesh->m_TM[cObject]=m_PickObjectScene->m_TM;
|
||
}
|
||
}
|
||
|
||
m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
|
||
/*
|
||
if(pSoundMap && nIndex!=-1)
|
||
{
|
||
pSoundMap->m_SoundPosList[nIndex]=m_PickObjectScene->m_TM.GetLoc();
|
||
vector3 vecPos=m_PickObjectScene->m_TM.GetLoc();
|
||
for(int i=0;i<LSIZEX*LSIZEY;i++)
|
||
{
|
||
if(m_HeightField.m_SectorScene[i].m_MapSound==pSoundMap)
|
||
{
|
||
m_HeightField.m_SectorScene[i].m_SoundObjectNode[nIndex]->SetPosition(vecPos);
|
||
break;
|
||
}
|
||
}
|
||
}*/
|
||
if( strcmp( m_PickObjectScene->m_strObjectName, "Sound.R3S" ) == 0 )
|
||
{
|
||
CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();
|
||
vector3 loc = m_PickObjectScene->m_TM.GetLoc();
|
||
sndMap.MoveAmbience( loc.x, loc.y, loc.z );
|
||
}
|
||
if( strcmp( m_PickObjectScene->m_strObjectName, "Cube.R3S" ) == 0 )
|
||
{
|
||
CBGMController & BGMC = CBGMController::GetInstance();
|
||
vector3 loc = m_PickObjectScene->m_TM.GetLoc();
|
||
BGMC.MovePoint( loc.x, loc.y, loc.z );
|
||
}
|
||
|
||
|
||
return;
|
||
}//<2F><><EFBFBD><EFBFBD> <20>̵<EFBFBD>
|
||
if(MoveMode==2)
|
||
{
|
||
m_PickObjectScene->m_TM._42+=fAddy;
|
||
for(int cObject=0;cObject<pMapMesh->m_ObjectSceneID.num;cObject++)
|
||
{
|
||
if(pMapMesh->m_ObjectSceneID[cObject]==m_PickObjectScene->m_ObjectID)
|
||
{
|
||
pMapMesh->m_TM[cObject]=m_PickObjectScene->m_TM;
|
||
}
|
||
}
|
||
m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
|
||
/*
|
||
if(pSoundMap && nIndex!=-1)
|
||
{
|
||
pSoundMap->m_SoundPosList[nIndex]=m_PickObjectScene->m_TM.GetLoc();
|
||
vector3 vecPos=m_PickObjectScene->m_TM.GetLoc();
|
||
for(int i=0;i<LSIZEX*LSIZEY;i++)
|
||
{
|
||
if(m_HeightField.m_SectorScene[i].m_MapSound==pSoundMap)
|
||
{
|
||
m_HeightField.m_SectorScene[i].m_SoundObjectNode[nIndex]->SetPosition(vecPos);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
if( strcmp( m_PickObjectScene->m_strObjectName, "Sound.R3S" ) == 0 )
|
||
{
|
||
CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();
|
||
vector3 loc = m_PickObjectScene->m_TM.GetLoc();
|
||
sndMap.MoveAmbience( loc.x, loc.y, loc.z );
|
||
}
|
||
if( strcmp( m_PickObjectScene->m_strObjectName, "Cube.R3S" ) == 0 )
|
||
{
|
||
CBGMController & BGMC = CBGMController::GetInstance();
|
||
vector3 loc = m_PickObjectScene->m_TM.GetLoc();
|
||
BGMC.MovePoint( loc.x, loc.y, loc.z );
|
||
}
|
||
|
||
return;
|
||
}// x-z<><7A> <20>̵<EFBFBD>
|
||
if(MoveMode==3)
|
||
{
|
||
if(KeyPressed(VK_LEFT)) m_PickObjectScene->m_TM._41+=1.0f;
|
||
if(KeyPressed(VK_RIGHT)) m_PickObjectScene->m_TM._41-=1.0f;
|
||
if(KeyPressed(VK_UP)) m_PickObjectScene->m_TM._43+=1.0f;
|
||
if(KeyPressed(VK_DOWN)) m_PickObjectScene->m_TM._43-=1.0f;
|
||
|
||
|
||
for(int cObject=0;cObject<pMapMesh->m_ObjectSceneID.num;cObject++)
|
||
{
|
||
if(pMapMesh->m_ObjectSceneID[cObject]==m_PickObjectScene->m_ObjectID)
|
||
{
|
||
pMapMesh->m_TM[cObject]=m_PickObjectScene->m_TM;
|
||
}
|
||
}
|
||
m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
|
||
/*
|
||
if(pSoundMap && nIndex!=-1)
|
||
{
|
||
pSoundMap->m_SoundPosList[nIndex]=m_PickObjectScene->m_TM.GetLoc();
|
||
vector3 vecPos=m_PickObjectScene->m_TM.GetLoc();
|
||
for(int i=0;i<LSIZEX*LSIZEY;i++)
|
||
{
|
||
if(m_HeightField.m_SectorScene[i].m_MapSound==pSoundMap)
|
||
{
|
||
m_HeightField.m_SectorScene[i].m_SoundObjectNode[nIndex]->SetPosition(vecPos);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
if( strcmp( m_PickObjectScene->m_strObjectName, "Sound.R3S" ) == 0 )
|
||
{
|
||
CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();
|
||
vector3 loc = m_PickObjectScene->m_TM.GetLoc();
|
||
sndMap.MoveAmbience( loc.x, loc.y, loc.z );
|
||
}
|
||
if( strcmp( m_PickObjectScene->m_strObjectName, "Cube.R3S" ) == 0 )
|
||
{
|
||
CBGMController & BGMC = CBGMController::GetInstance();
|
||
vector3 loc = m_PickObjectScene->m_TM.GetLoc();
|
||
BGMC.MovePoint( loc.x, loc.y, loc.z );
|
||
}
|
||
return;
|
||
}
|
||
|
||
int indexx=(int)(m_PickObjectScene->m_AccumulateTM._41/SECTORSIZE);
|
||
int indexy=(int)(m_PickObjectScene->m_AccumulateTM._43/SECTORSIZE);
|
||
|
||
int newindexx=(int)(fMx/SECTORSIZE);
|
||
int newindexy=(int)(fMz/SECTORSIZE);
|
||
|
||
if(indexx!=newindexx || indexy!=newindexy)
|
||
return;
|
||
|
||
matrix matTM,matInvTM;
|
||
matTM.Translation(vector3(fMx,fMy,fMz));
|
||
m_bIsPickObjectMoving=MOVE_OBJECT;
|
||
|
||
m_PickObjectScene->m_TM._41=matTM._41;
|
||
m_PickObjectScene->m_TM._42=matTM._42;
|
||
m_PickObjectScene->m_TM._43=matTM._43;
|
||
|
||
for(int cObject=0;cObject<pMapMesh->m_ObjectSceneID.num;cObject++)
|
||
{
|
||
if(pMapMesh->m_ObjectSceneID[cObject]==m_PickObjectScene->m_ObjectID)
|
||
{
|
||
pMapMesh->m_TM[cObject]=m_PickObjectScene->m_TM;
|
||
}
|
||
}
|
||
m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
|
||
/*
|
||
if(pSoundMap && nIndex!=-1)
|
||
{
|
||
pSoundMap->m_SoundPosList[nIndex]=m_PickObjectScene->m_TM.GetLoc();
|
||
vector3 vecPos=m_PickObjectScene->m_TM.GetLoc();
|
||
for(int i=0;i<LSIZEX*LSIZEY;i++)
|
||
{
|
||
if(m_HeightField.m_SectorScene[i].m_MapSound==pSoundMap)
|
||
{
|
||
m_HeightField.m_SectorScene[i].m_SoundObjectNode[nIndex]->SetPosition(vecPos);
|
||
break;
|
||
}
|
||
}
|
||
}*/
|
||
if( strcmp( m_PickObjectScene->m_strObjectName, "Sound.R3S" ) == 0 )
|
||
{
|
||
CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();
|
||
vector3 loc = m_PickObjectScene->m_TM.GetLoc();
|
||
sndMap.MoveAmbience( loc.x, loc.y, loc.z );
|
||
}
|
||
if( strcmp( m_PickObjectScene->m_strObjectName, "Cube.R3S" ) == 0 )
|
||
{
|
||
CBGMController & BGMC = CBGMController::GetInstance();
|
||
vector3 loc = m_PickObjectScene->m_TM.GetLoc();
|
||
BGMC.MovePoint( loc.x, loc.y, loc.z );
|
||
}
|
||
return;
|
||
}
|
||
///////dfgdfgsdrgserg
|
||
}
|
||
}
|
||
if(m_PickHouseScene)
|
||
{
|
||
if(MoveMode==1)
|
||
{
|
||
float fSaveX,fSaveY,fSaveZ;
|
||
CSectorHouseMap *SectorHouseMap=m_MapStorage.FindHouseMap(m_PickHouseScene->m_AccumulateTM._41,
|
||
m_PickHouseScene->m_AccumulateTM._43);
|
||
if(SectorHouseMap)
|
||
{
|
||
fSaveX=m_PickHouseScene->m_AccumulateTM._41;
|
||
fSaveY=m_PickHouseScene->m_AccumulateTM._42;
|
||
fSaveZ=m_PickHouseScene->m_AccumulateTM._43;
|
||
m_PickHouseScene->m_AccumulateTM._41=0.0f;
|
||
m_PickHouseScene->m_AccumulateTM._42=0.0f;
|
||
m_PickHouseScene->m_AccumulateTM._43=0.0f;
|
||
matrix AddAngleY;
|
||
AddAngleY.YRotation(fAngle);
|
||
m_PickHouseScene->m_AccumulateTM=m_PickHouseScene->m_AccumulateTM*AddAngleY;
|
||
m_PickHouseScene->m_AccumulateTM._41=fSaveX;
|
||
m_PickHouseScene->m_AccumulateTM._42=fSaveY;
|
||
m_PickHouseScene->m_AccumulateTM._43=fSaveZ;
|
||
for(int cObject=0;cObject<SectorHouseMap->m_TM.num;cObject++)
|
||
{
|
||
if( SectorHouseMap->m_HouseSceneID[cObject] == m_PickHouseScene->m_HouseSceneID )
|
||
{
|
||
SectorHouseMap->m_TM[cObject]=m_PickHouseScene->m_AccumulateTM;
|
||
}
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
if(MoveMode==2)
|
||
{
|
||
CSectorHouseMap *SectorHouseMap=m_MapStorage.FindHouseMap(m_PickHouseScene->m_AccumulateTM._41,
|
||
m_PickHouseScene->m_AccumulateTM._43);
|
||
if(SectorHouseMap)
|
||
{
|
||
for(int cObject=0;cObject<SectorHouseMap->m_TM.num;cObject++)
|
||
{
|
||
if( SectorHouseMap->m_HouseSceneID[cObject] == m_PickHouseScene->m_HouseSceneID )
|
||
{
|
||
m_PickHouseScene->m_AccumulateTM._42+=fAddy;
|
||
SectorHouseMap->m_TM[cObject]=m_PickHouseScene->m_AccumulateTM;
|
||
}
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
if(MoveMode==3)
|
||
{
|
||
CSectorHouseMap *SectorHouseMap=m_MapStorage.FindHouseMap(m_PickHouseScene->m_AccumulateTM._41,
|
||
m_PickHouseScene->m_AccumulateTM._43);
|
||
if(SectorHouseMap)
|
||
{
|
||
for(int cObject=0;cObject<SectorHouseMap->m_TM.num;cObject++)
|
||
{
|
||
if( SectorHouseMap->m_HouseSceneID[cObject] == m_PickHouseScene->m_HouseSceneID )
|
||
{
|
||
if(KeyPressed(VK_LEFT)) m_PickHouseScene->m_AccumulateTM._41+=1.0f;
|
||
if(KeyPressed(VK_RIGHT)) m_PickHouseScene->m_AccumulateTM._41-=1.0f;
|
||
if(KeyPressed(VK_UP)) m_PickHouseScene->m_AccumulateTM._43+=1.0f;
|
||
if(KeyPressed(VK_DOWN)) m_PickHouseScene->m_AccumulateTM._43-=1.0f;
|
||
|
||
SectorHouseMap->m_TM[cObject]=m_PickHouseScene->m_AccumulateTM;
|
||
}
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
int indexx=(int)(m_PickHouseScene->m_AccumulateTM._41/SECTORSIZE);
|
||
int indexy=(int)(m_PickHouseScene->m_AccumulateTM._43/SECTORSIZE);
|
||
|
||
int newindexx=(int)(fMx/SECTORSIZE);
|
||
int newindexy=(int)(fMz/SECTORSIZE);
|
||
|
||
CSectorHouseMap *SectorHouseMap=m_MapStorage.FindHouseMap(m_PickHouseScene->m_AccumulateTM._41,
|
||
m_PickHouseScene->m_AccumulateTM._43);
|
||
|
||
if(SectorHouseMap && newindexx==indexx && newindexy==indexy)
|
||
{
|
||
for(int cObject=0;cObject<SectorHouseMap->m_TM.num;cObject++)
|
||
{
|
||
if( SectorHouseMap->m_HouseSceneID[cObject] == m_PickHouseScene->m_HouseSceneID )
|
||
{
|
||
SectorHouseMap->m_TM[cObject]._41=fMx;
|
||
SectorHouseMap->m_TM[cObject]._42=fMy;
|
||
SectorHouseMap->m_TM[cObject]._43=fMz;
|
||
}
|
||
m_PickHouseScene->m_AccumulateTM._41=fMx;
|
||
m_PickHouseScene->m_AccumulateTM._42=fMy;
|
||
m_PickHouseScene->m_AccumulateTM._43=fMz;
|
||
}
|
||
}
|
||
m_bIsPickObjectMoving=MOVE_HOUSE;
|
||
}
|
||
|
||
|
||
}
|
||
|
||
void CSceneManager::CalculateLightmap(int LightmapMode)
|
||
{
|
||
if(m_PickHouseScene)
|
||
{
|
||
matrix mat;
|
||
mat=m_PickHouseScene->m_AccumulateTM;
|
||
|
||
D3DXMATRIX d3dmat;
|
||
d3dmat._11 = mat._11;
|
||
d3dmat._12 = mat._12;
|
||
d3dmat._13 = mat._13;
|
||
d3dmat._14 = mat._14;
|
||
|
||
d3dmat._21 = mat._21;
|
||
d3dmat._22 = mat._22;
|
||
d3dmat._23 = mat._23;
|
||
d3dmat._24 = mat._24;
|
||
|
||
d3dmat._31 = mat._31;
|
||
d3dmat._32 = mat._32;
|
||
d3dmat._33 = mat._33;
|
||
d3dmat._34 = mat._34;
|
||
|
||
d3dmat._41 = mat._41;
|
||
d3dmat._42 = mat._42;
|
||
d3dmat._43 = mat._43;
|
||
d3dmat._44 = mat._44;
|
||
|
||
int indexx=(int)(d3dmat._41/SECTORSIZE);
|
||
int indexy=(int)(d3dmat._43/SECTORSIZE);
|
||
|
||
CSectorLightManager *pLightManager = NULL;
|
||
for(int ix=0;ix<m_HeightField.GetLSizeX();ix++)
|
||
{
|
||
for(int iy=0;iy<m_HeightField.GetLSizeY();iy++)
|
||
{
|
||
if((m_HeightField.m_SectorScene[ix+iy*(m_HeightField.GetLSizeX())].m_SectorLightManager.m_IndexX == indexx) &&
|
||
(m_HeightField.m_SectorScene[ix+iy*(m_HeightField.GetLSizeX())].m_SectorLightManager.m_IndexY == indexy))
|
||
pLightManager = &(m_HeightField.m_SectorScene[ix+iy*(m_HeightField.GetLSizeX())].m_SectorLightManager);
|
||
}
|
||
}
|
||
|
||
vector3 vecMin;
|
||
vector3 vecMax;
|
||
|
||
m_PickHouseScene->m_HouseObject->CalcBox(vecMin,vecMax);
|
||
|
||
if(pLightManager == NULL) {
|
||
// MessageBox(NULL,"Light <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>.","error",MB_OK);
|
||
// return;
|
||
}
|
||
else
|
||
{
|
||
|
||
pLightManager->SelectLight(D3DXVECTOR3(vecMin.x,vecMin.y,vecMin.z),D3DXVECTOR3(vecMax.x,vecMax.y,vecMax.z),d3dmat);
|
||
|
||
}
|
||
|
||
|
||
|
||
/* D3DXMATRIX box;
|
||
|
||
// Min
|
||
D3DXMatrixIdentity(&box);
|
||
|
||
box._41 = vecMin.x;
|
||
box._42 = vecMin.y;
|
||
box._43 = vecMin.z;
|
||
|
||
D3DXMatrixMultiply(&box,&box,&d3dmat);
|
||
|
||
vecMin.x = box._41;
|
||
vecMin.y = box._42;
|
||
vecMin.z = box._43;
|
||
// max
|
||
D3DXMatrixIdentity(&box);
|
||
|
||
box._41 = vecMax.x;
|
||
box._42 = vecMax.y;
|
||
box._43 = vecMax.z;
|
||
|
||
D3DXMatrixMultiply(&box,&box,&d3dmat);
|
||
|
||
vecMax.x = box._41;
|
||
vecMax.y = box._42;
|
||
vecMax.z = box._43;
|
||
*/
|
||
|
||
|
||
|
||
if(LightmapMode == 2) // <20><><EFBFBD><EFBFBD> lightmap generator
|
||
{
|
||
|
||
if(pLightManager)
|
||
m_PickHouseScene->m_HouseObject->GenerateCaldronPointLightmap(mat,m_PickHouseScene->m_AccumulateTM,pLightManager->m_pSelectLights,pLightManager->m_iSelectLights);
|
||
else
|
||
m_PickHouseScene->m_HouseObject->GenerateCaldronPointLightmap(mat,m_PickHouseScene->m_AccumulateTM,NULL,0);
|
||
if(m_PickHouseScene->m_HouseObject->m_pInHouseObject)
|
||
{
|
||
m_PickHouseScene->m_HouseObject->m_pInHouseObject->MeshReload();
|
||
char strTextureName[256];
|
||
|
||
sprintf(strTextureName,"%s",m_PickHouseScene->m_strInName);
|
||
|
||
m_PickHouseScene->m_HouseObject->m_isHaveInLightmap = true;
|
||
m_PickHouseScene->m_HouseObject->m_InLightmap.Unload();
|
||
m_PickHouseScene->m_HouseObject->m_InLightmap.SetPath(LIGHTMAPTEXTUREPATH);
|
||
m_PickHouseScene->m_HouseObject->m_InLightmap.LoadNotCache(strTextureName);
|
||
|
||
m_PickHouseScene->m_HouseObject->m_nIndices.num=0;
|
||
}
|
||
|
||
/* switch(MessageBox(NULL,"lightmap <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD>ҿ<EFBFBD><D2BF><EFBFBD> No <20>Ͻÿ<CFBD>. <20><><EFBFBD><EFBFBD>Ʈ <20>ʿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ø<EFBFBD> <20><><EFBFBD><EFBFBD>)?","<22><><EFBFBD><EFBFBD>",MB_YESNO))
|
||
{
|
||
case IDNO:
|
||
|
||
m_PickHouseScene->m_HouseObject->GenerateNewLightmap(0,mat,m_PickHouseScene->m_AccumulateTM,pLightManager->m_pSelectLights,pLightManager->m_iSelectLights);
|
||
|
||
break;
|
||
case IDYES:
|
||
|
||
m_PickHouseScene->m_HouseObject->GenerateNewLightmap(1,mat,m_PickHouseScene->m_AccumulateTM,pLightManager->m_pSelectLights,pLightManager->m_iSelectLights);
|
||
|
||
break;
|
||
}
|
||
*/
|
||
/*
|
||
CConvertTexture ConvertTexture;
|
||
ConvertTexture.m_pddTexture=m_PickHouseScene->m_HouseObject->m_BackupLightmap.GetTexture();
|
||
ConvertTexture.m_dwHeight=m_PickHouseScene->m_HouseObject->m_BackupLightmap.m_dwHeight;
|
||
ConvertTexture.m_dwWidth=m_PickHouseScene->m_HouseObject->m_BackupLightmap.m_dwWidth;
|
||
ConvertTexture.GenerateMipMaps(true);
|
||
ConvertTexture.m_pddTexture=ConvertTexture.m_pddNewTexture;
|
||
ConvertTexture.m_pddNewTexture=NULL;
|
||
ConvertTexture.Compress(D3DFMT_DXT3);
|
||
char strDDSName[MAX_NAMEBUFFER];
|
||
char strNewName[MAX_NAMEBUFFER];
|
||
memset(strNewName,0,sizeof(char) * MAX_NAMEBUFFER);
|
||
strcpy(strNewName,m_PickHouseScene->m_strOutName);
|
||
char *ptr = strrchr(strNewName,'.');
|
||
*(ptr++) = '_';
|
||
*(ptr++) = 'N';
|
||
*(ptr++) = '.';
|
||
*(ptr++) = 'D';
|
||
*(ptr++) = 'D';
|
||
*(ptr++) = 'S';
|
||
|
||
sprintf(strDDSName,"%s\\%s",LIGHTMAPTEXTUREPATH,strNewName);
|
||
|
||
ConvertTexture.SaveDDS(strDDSName);
|
||
|
||
|
||
if(m_PickHouseScene->m_HouseObject->m_pOutHouseObject)
|
||
{
|
||
char HouseMeshObjectPath[MAX_NAMEBUFFER] = {0};
|
||
FILE *fp = NULL;
|
||
|
||
sprintf(HouseMeshObjectPath,"%s%s",HOUSEOBJECTPATH,m_PickHouseScene->m_strOutName);
|
||
int iLength = strlen(HouseMeshObjectPath);
|
||
HouseMeshObjectPath[iLength - 1] = '\0';
|
||
HouseMeshObjectPath[iLength - 2] = 'v';
|
||
HouseMeshObjectPath[iLength - 3] = 'u';
|
||
|
||
fp = fopen(HouseMeshObjectPath,"wb");
|
||
m_PickHouseScene->m_HouseObject->m_pOutHouseObject->AllLockBuffer();
|
||
|
||
fwrite((int *)&(m_PickHouseScene->m_HouseObject->m_pOutHouseObject->m_pVertexBuffer.num),sizeof(int),1,fp);
|
||
|
||
for(int i=0;i<m_PickHouseScene->m_HouseObject->m_pOutHouseObject->m_pVertexBuffer.num;i++)
|
||
{
|
||
int iNum = m_PickHouseScene->m_HouseObject->m_pOutHouseObject->m_nVertex[i];
|
||
fwrite((int *)&(iNum),sizeof(int),1,fp);
|
||
fwrite((m_PickHouseScene->m_HouseObject->m_pBackupVertex[i]),sizeof(MultiVertex)*(m_PickHouseScene->m_HouseObject->m_pOutHouseObject->m_nVertex[i]),1,fp);
|
||
}
|
||
|
||
m_PickHouseScene->m_HouseObject->m_pOutHouseObject->AllUnlockBuffer();
|
||
m_PickHouseScene->m_HouseObject->m_bConvertNight = false;
|
||
m_PickHouseScene->m_HouseObject->m_bNightUv = true;
|
||
m_PickHouseScene->m_HouseObject->m_bNightMap = true;
|
||
fclose(fp);
|
||
|
||
|
||
|
||
|
||
}*/
|
||
/*if(m_PickHouseScene->m_HouseObject->m_pMedHouseObject)
|
||
{
|
||
sprintf(HouseMeshObjectPath,"%s%s",HOUSEOBJECTPATH,m_PickHouseScene->m_strMedName);
|
||
m_PickHouseScene->m_HouseObject->m_pMedHouseObject->Save(HouseMeshObjectPath);
|
||
}
|
||
if(m_PickHouseScene->m_HouseObject->m_pInHouseObject)
|
||
{
|
||
sprintf(HouseMeshObjectPath,"%s%s",HOUSEOBJECTPATH,m_PickHouseScene->m_strInName);
|
||
m_PickHouseScene->m_HouseObject->m_pInHouseObject->Save(HouseMeshObjectPath);
|
||
}*/
|
||
|
||
|
||
}
|
||
else {
|
||
mat._43=mat._42=mat._41=0.0f;
|
||
if(pLightManager)
|
||
m_PickHouseScene->m_HouseObject->GenerateCaldronLightmap(mat,m_PickHouseScene->m_AccumulateTM,pLightManager->m_pSelectLights,pLightManager->m_iSelectLights);
|
||
else
|
||
m_PickHouseScene->m_HouseObject->GenerateCaldronLightmap(mat,m_PickHouseScene->m_AccumulateTM,NULL,0);
|
||
if(m_PickHouseScene->m_HouseObject->m_pOutHouseObject)
|
||
{
|
||
m_PickHouseScene->m_HouseObject->m_pOutHouseObject->MeshReload();
|
||
char strTextureName[256];
|
||
|
||
sprintf(strTextureName,"%s",m_PickHouseScene->m_strOutName);
|
||
|
||
m_PickHouseScene->m_HouseObject->m_isHaveLightmap = true;
|
||
m_PickHouseScene->m_HouseObject->m_Lightmap.Unload();
|
||
m_PickHouseScene->m_HouseObject->m_Lightmap.SetPath(LIGHTMAPTEXTUREPATH);
|
||
m_PickHouseScene->m_HouseObject->m_Lightmap.LoadNotCache(strTextureName);
|
||
|
||
m_PickHouseScene->m_HouseObject->m_nIndices.num=0;
|
||
}
|
||
if(m_PickHouseScene->m_HouseObject->m_pMedHouseObject)
|
||
{
|
||
m_PickHouseScene->m_HouseObject->m_pMedHouseObject->MeshReload();
|
||
}
|
||
/*m_PickHouseScene->m_HouseObject->GenerateLightmap(mat,m_PickHouseScene->m_AccumulateTM,LightmapMode);
|
||
|
||
char HouseMeshObjectPath[MAX_NAMEBUFFER];
|
||
|
||
if(m_PickHouseScene->m_HouseObject->m_pOutHouseObject)
|
||
{
|
||
sprintf(HouseMeshObjectPath,"%s%s",HOUSEOBJECTPATH,m_PickHouseScene->m_strOutName);
|
||
m_PickHouseScene->m_HouseObject->m_pOutHouseObject->Save(HouseMeshObjectPath);
|
||
|
||
}
|
||
if(m_PickHouseScene->m_HouseObject->m_pMedHouseObject)
|
||
{
|
||
sprintf(HouseMeshObjectPath,"%s%s",HOUSEOBJECTPATH,m_PickHouseScene->m_strMedName);
|
||
m_PickHouseScene->m_HouseObject->m_pMedHouseObject->Save(HouseMeshObjectPath);
|
||
}
|
||
if(m_PickHouseScene->m_HouseObject->m_pInHouseObject)
|
||
{
|
||
sprintf(HouseMeshObjectPath,"%s%s",HOUSEOBJECTPATH,m_PickHouseScene->m_strInName);
|
||
m_PickHouseScene->m_HouseObject->m_pInHouseObject->Save(HouseMeshObjectPath);
|
||
}
|
||
CConvertTexture ConvertTexture;
|
||
ConvertTexture.m_pddTexture=m_PickHouseScene->m_HouseObject->m_Lightmap.GetTexture();
|
||
ConvertTexture.m_dwHeight=m_PickHouseScene->m_HouseObject->m_Lightmap.m_dwHeight;
|
||
ConvertTexture.m_dwWidth=m_PickHouseScene->m_HouseObject->m_Lightmap.m_dwWidth;
|
||
ConvertTexture.GenerateMipMaps(true);
|
||
ConvertTexture.m_pddTexture=ConvertTexture.m_pddNewTexture;
|
||
ConvertTexture.m_pddNewTexture=NULL;
|
||
ConvertTexture.Compress(D3DFMT_DXT3);
|
||
char strDDSName[MAX_NAMEBUFFER];
|
||
sprintf(strDDSName,"%s\\%s",LIGHTMAPTEXTUREPATH,m_PickHouseScene->m_strOutName);
|
||
strDDSName[strlen(strDDSName)-1]='S';
|
||
strDDSName[strlen(strDDSName)-2]='D';
|
||
strDDSName[strlen(strDDSName)-3]='D';
|
||
ConvertTexture.SaveDDS(strDDSName);
|
||
*/
|
||
|
||
}
|
||
/*
|
||
CConvertTexture ConvertTexture;
|
||
ConvertTexture.Init(m_pd3dDevice);
|
||
ConvertTexture.m_ptexOrig=m_PickHouseScene->m_HouseObject->m_Lightmap.GetTexture();
|
||
ConvertTexture.m_dwHeight=m_PickHouseScene->m_HouseObject->m_Lightmap.m_dwHeight;
|
||
ConvertTexture.m_dwWidth=m_PickHouseScene->m_HouseObject->m_Lightmap.m_dwWidth;
|
||
ConvertTexture.Compress(D3DFMT_DXT3);
|
||
ConvertTexture.GenerateMipMaps();
|
||
char strDDSName[MAX_NAMEBUFFER];
|
||
sprintf(strDDSName,"%s\\%s",LIGHTMAPTEXTUREPATH,m_PickHouseScene->m_strOutName);
|
||
strDDSName[strlen(strDDSName)-1]='S';
|
||
strDDSName[strlen(strDDSName)-2]='D';
|
||
strDDSName[strlen(strDDSName)-3]='D';
|
||
ConvertTexture.SaveDDS(ConvertTexture.m_ptexNew,strDDSName);
|
||
*/
|
||
}
|
||
}
|
||
|
||
void CSceneManager::CalculateOctree()
|
||
{
|
||
if(m_PickHouseScene)
|
||
{
|
||
m_PickHouseScene->m_HouseObject->GenerateOctree();
|
||
|
||
FILE *fp;
|
||
char strOctreeFilename[MAX_NAMEBUFFER];
|
||
sprintf(strOctreeFilename,"%s\\%s",OCTREEPATH,m_PickHouseScene->m_strOutName);
|
||
|
||
strOctreeFilename[strlen(strOctreeFilename)-1]='T';
|
||
strOctreeFilename[strlen(strOctreeFilename)-2]='C';
|
||
strOctreeFilename[strlen(strOctreeFilename)-3]='O';
|
||
|
||
fp=fopen(strOctreeFilename,"wb");
|
||
//m_PickHouseScene->m_HouseObject->m_pOctree->m_pOctree->Save(fp);
|
||
m_PickHouseScene->m_HouseObject->m_pOctree->Save(fp);
|
||
fclose(fp);
|
||
}
|
||
}
|
||
|
||
void CSceneManager::DeleteAllData()
|
||
{
|
||
// m_HeightField.Destroy();
|
||
|
||
//=============
|
||
// Glare Test
|
||
//=============
|
||
m_GlareManager->Destroy();
|
||
|
||
for(int ix=0;ix<m_HeightField.GetLSizeX();ix++)
|
||
{
|
||
for(int iy=0;iy<m_HeightField.GetLSizeX();iy++)
|
||
{
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].UnloadAllData();
|
||
}
|
||
}
|
||
m_MapStorage.DeleteAllData();
|
||
|
||
}
|
||
|
||
CSectorScene* CSceneManager::PickTerrain(float fXp, float fYp, float fZp)
|
||
{
|
||
int ix,iy;
|
||
for(ix=0;ix<m_HeightField.GetLSizeX();ix++)
|
||
{
|
||
for(iy=0;iy<m_HeightField.GetLSizeX();iy++)
|
||
{
|
||
if( m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41 <= fXp &&
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41 + SECTORSIZE > fXp &&
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43 <= fZp &&
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43 + SECTORSIZE > fZp)
|
||
{
|
||
return &m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()];
|
||
}
|
||
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
void CSceneManager::DeletePickingObject()
|
||
{
|
||
if(m_PickObjectScene)
|
||
{
|
||
if(m_PickHouseScene)
|
||
{
|
||
int HouseSceneID=m_PickHouseScene->m_HouseSceneID;
|
||
|
||
|
||
m_MapStorage.DelInHouseObject(m_PickHouseScene->m_strOutName,
|
||
m_PickHouseScene->m_strMedName,
|
||
m_PickHouseScene->m_strInName,
|
||
m_PickObjectScene->m_ObjectID);
|
||
|
||
int delindexx=m_PickHouseScene->m_AccumulateTM._41/SECTORSIZE;
|
||
int delindexy=m_PickHouseScene->m_AccumulateTM._43/SECTORSIZE;
|
||
|
||
for(int i=0;i<m_PickHouseScene->m_HouseObject->m_ObjectList.num;i++)
|
||
{
|
||
if( m_PickHouseScene->m_HouseObject->m_ObjectList[i]->m_ObjectID==
|
||
m_PickObjectScene->m_ObjectID )
|
||
{
|
||
delete m_PickHouseScene->m_HouseObject->m_ObjectList[i];
|
||
m_PickHouseScene->m_HouseObject->m_ObjectList.DelIndex(i);
|
||
}
|
||
|
||
}
|
||
/*
|
||
m_PickHouseScene=NULL;
|
||
for(int cSector=0;cSector<LSIZEX*LSIZEY;cSector++)
|
||
{
|
||
sectorindexx=m_HeightField.m_SectorScene[cSector].m_AccumulateTM._41/SECTORSIZE;
|
||
sectorindexy=m_HeightField.m_SectorScene[cSector].m_AccumulateTM._43/SECTORSIZE;
|
||
if( delindexx == sectorindexx && delindexy == sectorindexy)
|
||
{
|
||
m_HeightField.m_SectorScene[cSector].GenerateHouseObject();
|
||
for(int cHouse=0;cHouse<m_HeightField.m_SectorScene[cSector].m_HouseObjectNode.num;cHouse++)
|
||
{
|
||
if(HouseSceneID==m_HeightField.m_SectorScene[cSector].m_HouseObjectNode[cHouse]->m_HouseSceneID)
|
||
{
|
||
m_PickHouseScene=m_HeightField.m_SectorScene[cSector].m_HouseObjectNode[cHouse];
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
m_PickObjectScene=NULL;
|
||
*/
|
||
m_PickObjectScene=NULL;
|
||
}
|
||
else
|
||
{
|
||
if(m_RBspSceneManager.m_pCurrentBspScene == NULL)
|
||
{
|
||
/*
|
||
CSectorSoundMap *pSoundMap=NULL;
|
||
int nIndex=-1;
|
||
if(strcmp(m_PickObjectScene->m_strObjectName,"Sound.R3S")==0)
|
||
{
|
||
pSoundMap=m_MapStorage.FindSoundMap(m_PickObjectScene->m_TM._41,m_PickObjectScene->m_TM._43);
|
||
float fLens=10.0f;
|
||
vector3 vecLens;
|
||
for(int i=0;i<pSoundMap->m_SoundPosList.num;i++)
|
||
{
|
||
vecLens=m_PickObjectScene->m_TM.GetLoc()-pSoundMap->m_SoundPosList[i];
|
||
if(fLens>=vecLens.GetLens())
|
||
{
|
||
fLens=vecLens.GetLens();
|
||
nIndex=i;
|
||
}
|
||
}
|
||
if(nIndex==-1)
|
||
return;
|
||
}
|
||
if(pSoundMap && nIndex!=-1)
|
||
{
|
||
pSoundMap->m_SoundPosList[nIndex]=m_PickObjectScene->m_TM.GetLoc();
|
||
pSoundMap->m_SoundPosList.DelIndex(nIndex);
|
||
pSoundMap->m_SoundMinRangeList.DelIndex(nIndex);
|
||
pSoundMap->m_SoundMaxRangeList.DelIndex(nIndex);
|
||
delete [] pSoundMap->m_strSoundFilenameList[nIndex];
|
||
pSoundMap->m_strSoundFilenameList.DelIndex(nIndex);
|
||
|
||
vector3 vecPos=m_PickObjectScene->m_TM.GetLoc();
|
||
for(int i=0;i<LSIZEX*LSIZEY;i++)
|
||
{
|
||
if(m_HeightField.m_SectorScene[i].m_MapSound==pSoundMap)
|
||
{
|
||
delete m_HeightField.m_SectorScene[i].m_SoundObjectNode[nIndex];
|
||
m_HeightField.m_SectorScene[i].m_SoundObjectNode.DelIndex(nIndex);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
if( strcmp( m_PickObjectScene->m_strObjectName, "Sound.R3S" ) == 0 )
|
||
{
|
||
CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();
|
||
vector3 loc = m_PickObjectScene->m_TM.GetLoc();
|
||
sndMap.DeleteAmbience( loc.x, loc.y, loc.z );
|
||
}
|
||
|
||
if( strcmp( m_PickObjectScene->m_strObjectName, "Cube.R3S" ) == 0 )
|
||
{
|
||
try
|
||
{
|
||
CBGMController & BGMC = CBGMController::GetInstance();
|
||
vector3 loc = m_PickObjectScene->m_TM.GetLoc();
|
||
BGMC.DeletePoint();
|
||
}
|
||
catch( exception & e )
|
||
{
|
||
MessageBox( NULL, e.what(), "Error!!", MB_OK );
|
||
return;
|
||
}
|
||
}
|
||
|
||
m_MapStorage.DelMeshMap(m_PickObjectScene->m_TM._41,m_PickObjectScene->m_TM._42,m_PickObjectScene->m_TM._43,
|
||
m_PickObjectScene->m_ObjectID);
|
||
|
||
int delindexx=m_PickObjectScene->m_TM._41/SECTORSIZE;
|
||
int delindexy=m_PickObjectScene->m_TM._43/SECTORSIZE;
|
||
m_HeightField.GenerateSectorSceneObjects( delindexx, delindexy );
|
||
|
||
m_PickObjectScene=NULL;
|
||
|
||
/*
|
||
CSectorMeshMap *pMapMesh=CMapStorage::FindMeshMap(m_PickObjectScene->m_TM._41,m_PickObjectScene->m_TM._43);
|
||
if(pMapMesh==NULL)
|
||
return;
|
||
|
||
if(MoveMode==1)
|
||
{
|
||
matrix AddAngleY;
|
||
AddAngleY.YRotation(fAngle);
|
||
m_PickObjectScene->m_TM=AddAngleY*m_PickObjectScene->m_TM;
|
||
for(int cObject=0;cObject<pMapMesh->m_ObjectSceneID.num;cObject++)
|
||
{
|
||
if(pMapMesh->m_ObjectSceneID[cObject]==m_PickObjectScene->m_ObjectID)
|
||
{
|
||
pMapMesh->m_TM[cObject]=m_PickObjectScene->m_TM;
|
||
}
|
||
}
|
||
|
||
return;
|
||
}
|
||
*/
|
||
} // if(m_RBspSceneManager.m_pCurrentBspScene == NULL)
|
||
else
|
||
{
|
||
RBspScene *pScene = m_RBspSceneManager.m_pCurrentBspScene;
|
||
|
||
D3DXVECTOR3 vecR3SCenter = D3DXVECTOR3(m_PickObjectScene->m_TM._41,
|
||
m_PickObjectScene->m_TM._42,
|
||
m_PickObjectScene->m_TM._43);
|
||
|
||
int iLeaf = pScene->FindWorldLeaf(vecR3SCenter);
|
||
pScene->m_pLeafExs[iLeaf].DeletePickR3SObject();
|
||
pScene->GenerateR3SObject();
|
||
m_PickObjectScene=NULL;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
if(m_PickLightScene)
|
||
{
|
||
if(m_PickHouseScene==NULL)
|
||
return;
|
||
int HouseSceneID=m_PickHouseScene->m_HouseSceneID;
|
||
m_MapStorage.DelInHouseLight(m_PickHouseScene->m_strOutName,
|
||
m_PickHouseScene->m_strMedName,
|
||
m_PickHouseScene->m_strInName,
|
||
m_PickLightScene->m_LightID);
|
||
|
||
for(int i=0;i<m_PickHouseScene->m_HouseObject->m_LightList.num;i++)
|
||
{
|
||
if( m_PickHouseScene->m_HouseObject->m_LightList[i]->m_LightID==
|
||
m_PickLightScene->m_LightID )
|
||
{
|
||
delete m_PickHouseScene->m_HouseObject->m_LightList[i];
|
||
m_PickHouseScene->m_HouseObject->m_LightList.DelIndex(i);
|
||
}
|
||
}
|
||
m_PickLightScene=NULL;
|
||
/*
|
||
int delindexx=m_PickHouseScene->m_AccumulateTM._41/SECTORSIZE;
|
||
int delindexy=m_PickHouseScene->m_AccumulateTM._43/SECTORSIZE;
|
||
|
||
int sectorindexx,sectorindexy;
|
||
for(int cSector=0;cSector<LSIZEX*LSIZEY;cSector++)
|
||
{
|
||
sectorindexx=m_HeightField.m_SectorScene[cSector].m_AccumulateTM._41/SECTORSIZE;
|
||
sectorindexy=m_HeightField.m_SectorScene[cSector].m_AccumulateTM._43/SECTORSIZE;
|
||
if( delindexx == sectorindexx && delindexy == sectorindexy)
|
||
{
|
||
m_HeightField.m_SectorScene[cSector].GenerateHouseObject();
|
||
for(int cHouse=0;cHouse<m_HeightField.m_SectorScene[cSector].m_HouseObjectNode.num;cHouse++)
|
||
{
|
||
if(HouseSceneID==m_HeightField.m_SectorScene[cSector].m_HouseObjectNode[cHouse]->m_HouseSceneID)
|
||
{
|
||
m_PickHouseScene=m_HeightField.m_SectorScene[cSector].m_HouseObjectNode[cHouse];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
return;
|
||
}
|
||
if(m_PickHouseScene)
|
||
{
|
||
int delindexx=m_PickHouseScene->m_AccumulateTM._41/SECTORSIZE;
|
||
int delindexy=m_PickHouseScene->m_AccumulateTM._43/SECTORSIZE;
|
||
|
||
m_MapStorage.DelHouseMap(m_PickHouseScene->m_AccumulateTM._41,
|
||
m_PickHouseScene->m_AccumulateTM._42,
|
||
m_PickHouseScene->m_AccumulateTM._43,
|
||
m_PickHouseScene->m_HouseSceneID);
|
||
|
||
m_PickHouseScene=NULL;
|
||
int sectorindexx,sectorindexy;
|
||
for(int cSector=0;cSector<m_HeightField.GetLSizeX()*m_HeightField.GetLSizeY();cSector++)
|
||
{
|
||
sectorindexx=m_HeightField.m_SectorScene[cSector].m_AccumulateTM._41/SECTORSIZE;
|
||
sectorindexy=m_HeightField.m_SectorScene[cSector].m_AccumulateTM._43/SECTORSIZE;
|
||
if( delindexx == sectorindexx && delindexy == sectorindexy)
|
||
{
|
||
m_HeightField.m_SectorScene[cSector].GenerateHouseObject();
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
|
||
CZ3DGeneralChrModel* CSceneManager::AddCharacter( const char* szGCMDSName, const char* szFaceType, const char* szHairStyle )
|
||
{
|
||
return m_CharacterManager.AddCharacter(szGCMDSName, szFaceType, szHairStyle);
|
||
}
|
||
|
||
void CSceneManager::Undo()
|
||
{
|
||
matrix matUndoData=m_matUndo;
|
||
MakeUndoData();
|
||
if(m_PickLightScene)
|
||
{
|
||
m_PickLightScene->m_TM=matUndoData;
|
||
CInHouseObjectMap *InHouseMap=m_MapStorage.FindInHouseMap(m_PickHouseScene->m_strOutName,
|
||
m_PickHouseScene->m_strMedName,
|
||
m_PickHouseScene->m_strInName,
|
||
m_PickHouseScene->m_strBSPName);
|
||
for(int cLight=0;cLight<InHouseMap->m_LightID.num;cLight++)
|
||
{
|
||
if(m_PickLightScene->m_LightID==InHouseMap->m_LightID[cLight])
|
||
{
|
||
InHouseMap->m_matLightList[cLight]=m_PickLightScene->m_TM;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
if(m_PickObjectScene)
|
||
{
|
||
if(m_PickHouseScene)
|
||
{
|
||
m_PickObjectScene->m_TM=matUndoData;
|
||
CInHouseObjectMap *InHouseMap=m_MapStorage.FindInHouseMap(m_PickHouseScene->m_strOutName,
|
||
m_PickHouseScene->m_strMedName,
|
||
m_PickHouseScene->m_strInName,
|
||
m_PickHouseScene->m_strBSPName);
|
||
for(int cObject=0;cObject<InHouseMap->m_ObjectID.num;cObject++)
|
||
{
|
||
if(m_PickObjectScene->m_ObjectID==InHouseMap->m_ObjectID[cObject])
|
||
{
|
||
InHouseMap->m_matObjectList[cObject]=m_PickObjectScene->m_TM;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
m_PickObjectScene->m_TM=matUndoData;
|
||
CSectorMeshMap *pMapMesh=m_MapStorage.FindMeshMap(m_PickObjectScene->m_TM._41,m_PickObjectScene->m_TM._43);
|
||
if(pMapMesh==NULL)
|
||
return;
|
||
for(int cObject=0;cObject<pMapMesh->m_ObjectSceneID.num;cObject++)
|
||
{
|
||
if(pMapMesh->m_ObjectSceneID[cObject]==m_PickObjectScene->m_ObjectID)
|
||
{
|
||
pMapMesh->m_TM[cObject]=m_PickObjectScene->m_TM;
|
||
}
|
||
}
|
||
m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
|
||
return;
|
||
}
|
||
}
|
||
if(m_PickHouseScene)
|
||
{
|
||
CSectorHouseMap *SectorHouseMap=m_MapStorage.FindHouseMap(m_PickHouseScene->m_AccumulateTM._41,
|
||
m_PickHouseScene->m_AccumulateTM._43);
|
||
m_PickHouseScene->m_AccumulateTM=matUndoData;
|
||
for(int cObject=0;cObject<SectorHouseMap->m_TM.num;cObject++)
|
||
{
|
||
if( SectorHouseMap->m_HouseSceneID[cObject] == m_PickHouseScene->m_HouseSceneID )
|
||
{
|
||
SectorHouseMap->m_TM[cObject]=matUndoData;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CSceneManager::MakeUndoData()
|
||
{
|
||
if(m_PickLightScene)
|
||
{
|
||
m_matUndo=m_PickLightScene->m_TM;
|
||
}
|
||
if(m_PickObjectScene)
|
||
{
|
||
m_matUndo=m_PickObjectScene->m_TM;
|
||
}
|
||
if(m_PickHouseScene && m_PickLightScene==NULL && m_PickObjectScene==NULL)
|
||
{
|
||
m_matUndo=m_PickHouseScene->m_AccumulateTM;
|
||
}
|
||
}
|
||
|
||
void CSceneManager::Create(CInitValue initValue,char *strPath)
|
||
{
|
||
/*
|
||
CRenderOption::m_GrassRendering=1;
|
||
CRenderOption::m_GrassAnimationUseVertexShader=1;
|
||
CRenderOption::m_GrassRenderRange=9;
|
||
CRenderOption::m_RangeGrassRender=0
|
||
|
||
CRenderOption::m_FullSceneGlare=1;
|
||
CRenderOption::m_FullSceneAnti=0;
|
||
CRenderOption::m_FullSceneSpecularGlare=1;
|
||
|
||
CRenderOption::m_WaterBumpEnvRendering=1;
|
||
|
||
CRenderOption::m_TerrainMultiDetalTexture=1;
|
||
|
||
CRenderOption::m_TerrainRange=7;
|
||
|
||
CRenderOption::m_BuildingLightmap=1;
|
||
|
||
CRenderOption::m_TreeAnimation=1;
|
||
|
||
CRenderOption::m_CharacterPerPixelLighting=1;
|
||
CRenderOption::m_CharacterPerPixelSpecularLighting=1;
|
||
CRenderOption::m_CharacterSelfShadow=1;
|
||
|
||
CRenderOption::m_DepthOfField=0;
|
||
CRenderOption::m_CharacterProjectShadowTerrain=1;
|
||
CRenderOption::m_CharacterProjectShadowBuilding=1;
|
||
|
||
CRenderOption::m_ObjectLOD=4;
|
||
CRenderOption::m_TextureMethod=1;
|
||
CRenderOption::m_strBaseGraphicsDataPath[256];
|
||
|
||
CRenderOption::m_ObjectProjectShadow=1;
|
||
CRenderOption::m_TreeProjectShadow=1;
|
||
CRenderOption::m_AllObjectBump=1;
|
||
*/
|
||
CRenderOption::m_AllObjectBump=0;
|
||
|
||
CRenderOption::m_ObjectProjectShadow=0;
|
||
CRenderOption::m_TreeProjectShadow=0;
|
||
|
||
m_bEditor=false;
|
||
/*
|
||
m_DetailCharShadow=initValue.m_CharShadow;
|
||
m_DetailMapShadow=initValue.m_MapShadow;
|
||
m_DetailBuildShadow=initValue.m_BuildShadow;
|
||
m_DetailTerrain=initValue.m_TerrainDetail;
|
||
m_DetailChrMesh=initValue.m_CharDetail;
|
||
m_DetailViewRange=initValue.m_ViewRange;
|
||
m_DetailWaterReflection=initValue.m_WaterReflection;
|
||
m_DetailLensflare=initValue.m_Lensflare;
|
||
m_DetailTreeDetail=initValue.m_TreeDetail;
|
||
*/
|
||
DETAILGROUND=25;
|
||
|
||
switch(CRenderOption::m_ObjectLOD)
|
||
{
|
||
case 0:
|
||
MAX_HOUSEVIEWRANGE=16000.0f;
|
||
MAX_HOUSEDISAPPER=MAX_HOUSEVIEWRANGE-1000.0f;
|
||
MAX_OUTVIEWRANGE=15000.0f;
|
||
MAX_MEDVIEWRANGE=15000.0f;
|
||
MAX_INVIEWRANGE=3000.0f;
|
||
MAX_OBJECTVIEWRANBE=5000.0f;
|
||
MAX_OBJECTDISAPPER=MAX_OBJECTVIEWRANBE-400.0f;
|
||
LENS_REALPOLYTREE=5000.0f;
|
||
break;
|
||
case 1:
|
||
MAX_HOUSEVIEWRANGE=30000.0f;
|
||
MAX_HOUSEDISAPPER=MAX_HOUSEVIEWRANGE-2000.0f;
|
||
MAX_OUTVIEWRANGE=15000.0f;
|
||
MAX_MEDVIEWRANGE=15000.0f;
|
||
MAX_INVIEWRANGE=3000.0f;
|
||
MAX_OBJECTVIEWRANBE=5000.0f;
|
||
MAX_OBJECTDISAPPER=MAX_OBJECTVIEWRANBE-1000.0f;
|
||
LENS_REALPOLYTREE=8000.0f;
|
||
break;
|
||
case 2:
|
||
MAX_HOUSEVIEWRANGE=60000.0f;
|
||
MAX_HOUSEDISAPPER=MAX_HOUSEVIEWRANGE-3000.0f;
|
||
MAX_OUTVIEWRANGE=15000.0f;
|
||
MAX_MEDVIEWRANGE=15000.0f;
|
||
MAX_INVIEWRANGE=3000.0f;
|
||
MAX_OBJECTVIEWRANBE=5000.0f;
|
||
MAX_OBJECTDISAPPER=MAX_OBJECTVIEWRANBE-1000.0f;
|
||
LENS_REALPOLYTREE=10000.0f;
|
||
break;
|
||
case 3:
|
||
MAX_HOUSEVIEWRANGE=80000.0f;
|
||
MAX_HOUSEDISAPPER=MAX_HOUSEVIEWRANGE-4000.0f;
|
||
MAX_OUTVIEWRANGE=15000.0f;
|
||
MAX_MEDVIEWRANGE=15000.0f;
|
||
MAX_INVIEWRANGE=3000.0f;
|
||
MAX_OBJECTVIEWRANBE=10000.0f;
|
||
MAX_OBJECTDISAPPER=MAX_OBJECTVIEWRANBE-1000.0f;
|
||
LENS_REALPOLYTREE=12000.0f;
|
||
break;
|
||
}
|
||
//LogMessage(strPath);
|
||
/*
|
||
char strNsTexturePath[256];
|
||
|
||
sprintf(strNsTexturePath,"%s\\Texture\\Interface\\",strPath);
|
||
CTexture::SetPath(strNsTexturePath);
|
||
*/
|
||
|
||
|
||
if(CRenderOption::m_FullSceneGlare)
|
||
{
|
||
m_LightEffectManager.Create(m_ScreenSize);
|
||
}
|
||
|
||
CSceneStateMgr::_Init();
|
||
SetSceneManagerPath(strPath);
|
||
|
||
SHADOWSIZE=256;
|
||
//LogMessage("Perlin Noise Create");
|
||
CPerlinNoise::Init();
|
||
//LogMessage("HeightField Create");
|
||
//m_HeightField.Create(7,7,&m_MapStorage);
|
||
m_HeightField.Create(CRenderOption::m_TerrainRange,CRenderOption::m_TerrainRange,&m_MapStorage);
|
||
//LogMessage("WeatherManager Create");
|
||
m_CollisionDetection.m_HeightField=&m_HeightField;
|
||
//LogMessage("CharacterMan2ger Create");
|
||
m_InstanceObjectManager.Create(m_pd3dDevice);
|
||
m_WeatherManager.Load();
|
||
///////
|
||
char strTableName[256] = {0,};
|
||
char strBuffer[256] = {0,};
|
||
char *strPtr = NULL;
|
||
strcpy(strTableName,WEATHERPATH);
|
||
strPtr = strrchr(strTableName,'.');
|
||
strPtr++;
|
||
(*strPtr) = 't';
|
||
strPtr++;
|
||
(*strPtr) = 'a';
|
||
strPtr++;
|
||
(*strPtr) = 'b';
|
||
strPtr++;
|
||
(*strPtr) = 'l';
|
||
strPtr++;
|
||
(*strPtr) = 'e';
|
||
strPtr++;
|
||
(*strPtr) = 0;
|
||
|
||
FILE *fp = fopen(strTableName,"rt");
|
||
if(fp)
|
||
{
|
||
|
||
int *iPtr;
|
||
int iPtrNum;
|
||
char *str;
|
||
fgets(strBuffer,256,fp);
|
||
iPtrNum = atoi(strBuffer);
|
||
iPtr = new int[iPtrNum];
|
||
memset(strBuffer,0,sizeof(char) * 256);
|
||
fgets(strBuffer,256,fp);
|
||
int iNum;
|
||
|
||
for(iNum = 0; iNum < iPtrNum; iNum++)
|
||
{
|
||
if(iNum == 0)
|
||
str = strtok(strBuffer," \n");
|
||
else
|
||
str = strtok(NULL," \n");
|
||
iPtr[iNum] = atoi(str);
|
||
}
|
||
|
||
fclose(fp);
|
||
|
||
m_WeatherManager.LoadSubTable(iPtr,iPtrNum);
|
||
delete[] iPtr;
|
||
|
||
|
||
}
|
||
////////
|
||
m_MapStorage.SetLoadMode(1);
|
||
|
||
m_EffectManager.SetDevice(m_pd3dDevice);
|
||
//////
|
||
|
||
//CParticle::SetMatPosition(&m_ViewCamera->m_matPosition);
|
||
|
||
//SetSceneManagerPath("c:\\MP-Project");
|
||
strcpy(CRenderOption::m_strBaseGraphicsDataPath,"Zone1");
|
||
///strcpy(CRenderOption::m_strBaseGraphicsDataPath,"");
|
||
BaseGraphicsDataLoad(CRenderOption::m_strBaseGraphicsDataPath);
|
||
m_WeatherManager.Create();
|
||
m_CharacterManager.Create();
|
||
m_CharacterManager.SetHeightField(&m_HeightField);
|
||
///////////////////ũ<><C5A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>
|
||
|
||
if(m_bSnowFall) {
|
||
D3DXMATRIX tmpview;
|
||
m_pd3dDevice->GetTransform(D3DTS_VIEW,&tmpview);
|
||
D3DXMatrixInverse(&tmpview,NULL,&tmpview);
|
||
|
||
vector3 tmppos;
|
||
tmppos.x = tmpview._41;
|
||
tmppos.y = tmpview._42;
|
||
tmppos.z = tmpview._43;
|
||
/*m_SnowFall.SetWorldValue(0.0f,-2.0f,0.0f,8.0f,-3.0f,8.0f,"snow.dds");
|
||
//m_SnowFall.Init(GetDevice(),300,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 100.0f);
|
||
m_SnowFall.Init(GetDevice(),500,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 2000.0f);
|
||
*/
|
||
|
||
m_SnowFall.SetWorldValue(0.0f,-2.0f,0.0f,1.0f,-0.5f,1.0f,"snow.dds");
|
||
//m_SnowFall.Init(GetDevice(),300,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 100.0f);
|
||
m_SnowFall.Init(GetDevice(),100,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 2000.0f);
|
||
}
|
||
|
||
//////////////////
|
||
/**/
|
||
if(m_pWaterTexGenerator == NULL) {
|
||
m_pWaterTexGenerator = new WBWaterNormalTexGenerator;
|
||
m_pWaterTexGenerator->Init(GetDevice(),128,128,"Displacement.dds");
|
||
}
|
||
if(m_pEnvPlaneTex != NULL)
|
||
delete m_pEnvPlaneTex;
|
||
|
||
m_pEnvPlaneTex = new WBEnvPlaneTex;
|
||
m_pEnvPlaneTex->Init(GetDevice(),256,256);
|
||
|
||
|
||
if(m_pBlackGlare != NULL)
|
||
delete m_pBlackGlare;
|
||
m_pBlackGlare = new CTexture;
|
||
CTexture::SetPath(EFFECTTEXTUREPATH);
|
||
m_pBlackGlare->Load("spec_black.dds");
|
||
|
||
/* if(m_pEsfCasher)
|
||
delete m_pEsfCasher;
|
||
|
||
m_pEsfCasher = new CEffectCasher;
|
||
m_pEsfCasher->BuildHashTable(EFFECTSCRIPTPATH);
|
||
*/
|
||
if(CRenderOption::m_bRain) {
|
||
m_pRainParticle = new CRainParticle;
|
||
|
||
m_pRainParticle->Init(1000,"RainPar.dds");
|
||
m_pRainParticle->SetMaxLife(75.0f);
|
||
m_pRainParticle->SetColor(1.0f,1.0f,1.0f,1.0f,1.0f,1.0f);
|
||
m_pRainParticle->SetVisible(1.0f,0.3f);
|
||
m_pRainParticle->SetSize(0.1f,2.5f,0.1f,2.5f);
|
||
m_pRainParticle->SetBaseMass(1.25f);
|
||
m_pRainParticle->SetFraction(0.0f);
|
||
m_pRainParticle->SetGravity( 0.0f, 0.0001f, 0.0f );
|
||
m_pRainParticle->Explode(0.12f, 777 );
|
||
|
||
}
|
||
|
||
}
|
||
/*
|
||
CParticleSequence * CSceneManager::AddParticle(vector3 vecPos,vector3 vecTarget)
|
||
{
|
||
return m_ParticleManager.AddParticle(SMOKE_PARTICLE,vecPos,vecTarget);
|
||
//return m_Particle.
|
||
}
|
||
*/
|
||
void CSceneManager::DeleteCharacter(CZ3DGeneralChrModel *pDelChr)
|
||
{
|
||
m_CharacterManager.DeleteCharacter(pDelChr);
|
||
}
|
||
|
||
int CSceneManager::AddInstanceObject(char *strObjectName, vector3 vecPos)
|
||
{
|
||
return m_InstanceObjectManager.AddInstanceObject(strObjectName,vecPos);
|
||
}
|
||
|
||
void CSceneManager::DeleteInstanceObject(int InstanceObjectID)
|
||
{
|
||
m_InstanceObjectManager.DeleteInstanceObject(InstanceObjectID);
|
||
}
|
||
|
||
int CSceneManager::MouseOnCheckInstanceObject(int px, int py)
|
||
{
|
||
return m_InstanceObjectManager.MouseOnCheckInstanceObject(px,py);
|
||
}
|
||
|
||
void CSceneManager::SetIntanceObjectColor(int ID,color Color)
|
||
{
|
||
m_InstanceObjectManager.SetInstanceObjectColor(ID,Color);
|
||
}
|
||
|
||
void CSceneManager::SetAllInstanceObjectColor(color Color)
|
||
{
|
||
m_InstanceObjectManager.SetAllObjectColor(Color);
|
||
}
|
||
|
||
void CSceneManager::PickMakeRay(int dx, int dy,int ScreenX,int ScreenY)
|
||
{
|
||
matrix matProj,matView,matInv;
|
||
m_pd3dDevice->GetTransform(D3DTS_PROJECTION,matProj);
|
||
m_pd3dDevice->GetTransform(D3DTS_VIEW,matView);
|
||
|
||
vector3 v;
|
||
v.x= ( ( (2.0f*dx) / ScreenX) -1 ) / matProj._11;
|
||
v.y=-( ( (2.0f*dy) / ScreenY) -1 ) / matProj._22;
|
||
v.z= 1.0f;
|
||
|
||
matInv.Inverse(matView);
|
||
m_vecPickRayStart.x=matInv._41;
|
||
m_vecPickRayStart.y=matInv._42;
|
||
m_vecPickRayStart.z=matInv._43;
|
||
|
||
m_vecPickRayDir.x=v.x*matInv._11 + v.y*matInv._21 + v.z*matInv._31;
|
||
m_vecPickRayDir.y=v.x*matInv._12 + v.y*matInv._22 + v.z*matInv._32;
|
||
m_vecPickRayDir.z=v.x*matInv._13 + v.y*matInv._23 + v.z*matInv._33;
|
||
}
|
||
|
||
CSectorScene* CSceneManager::PickTerrain()
|
||
{
|
||
m_vecPickRayStart;
|
||
m_vecPickRayDir;
|
||
|
||
float fIntersection;
|
||
|
||
int ix,iy;
|
||
for(ix=0;ix<m_HeightField.GetLSizeX();ix++)
|
||
{
|
||
for(iy=0;iy<m_HeightField.GetLSizeY();iy++)
|
||
{
|
||
vector3 vecSectorPoly[3];
|
||
vecSectorPoly[0].x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41;
|
||
vecSectorPoly[0].z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43;
|
||
vecSectorPoly[0].y=0.0f;
|
||
|
||
vecSectorPoly[1].x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41+SECTORSIZE;
|
||
vecSectorPoly[1].z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43;
|
||
vecSectorPoly[1].y=0.0f;
|
||
|
||
vecSectorPoly[2].x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41;
|
||
vecSectorPoly[2].z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43+SECTORSIZE;
|
||
vecSectorPoly[2].y=0.0f;
|
||
|
||
if(CIntersection::PolygonRay(m_vecPickRayStart,m_vecPickRayStart+m_vecPickRayDir*100000.0f,vecSectorPoly,fIntersection)==1)
|
||
{
|
||
return &m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()];
|
||
}
|
||
|
||
vecSectorPoly[0].x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41+SECTORSIZE;
|
||
vecSectorPoly[0].z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43;
|
||
vecSectorPoly[0].y=0.0f;
|
||
|
||
vecSectorPoly[1].x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41;
|
||
vecSectorPoly[1].z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43+SECTORSIZE;
|
||
vecSectorPoly[1].y=0.0f;
|
||
|
||
vecSectorPoly[2].x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41+SECTORSIZE;
|
||
vecSectorPoly[2].z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43+SECTORSIZE;
|
||
vecSectorPoly[2].y=0.0f;
|
||
|
||
if(CIntersection::PolygonRay(m_vecPickRayStart,m_vecPickRayStart+m_vecPickRayDir*100000.0f,vecSectorPoly,fIntersection)==1)
|
||
{
|
||
return &m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()];
|
||
}
|
||
}
|
||
}
|
||
return NULL;
|
||
/*
|
||
int ix,iy;
|
||
for(ix=0;ix<LSIZEX;ix++)
|
||
{
|
||
for(iy=0;iy<LSIZEY;iy++)
|
||
{
|
||
if( m_HeightField.m_SectorScene[ix+iy*LSIZEX].m_AccumulateTM._41 <= fXp &&
|
||
m_HeightField.m_SectorScene[ix+iy*LSIZEX].m_AccumulateTM._41 + SECTORSIZE > fXp &&
|
||
m_HeightField.m_SectorScene[ix+iy*LSIZEX].m_AccumulateTM._43 <= fZp &&
|
||
m_HeightField.m_SectorScene[ix+iy*LSIZEX].m_AccumulateTM._43 + SECTORSIZE > fZp)
|
||
{
|
||
return &m_HeightField.m_SectorScene[ix+iy*LSIZEX];
|
||
}
|
||
|
||
}
|
||
}
|
||
*/
|
||
|
||
//m_vecPickRayStart=;
|
||
//m_vecPickRayEnd=;
|
||
}
|
||
|
||
int CSceneManager::GetCharacterCount()
|
||
{
|
||
//return m_CharacterManager.m_CharacterScreenPositionList.num;
|
||
return m_CharacterManager.m_CharacterList.num;
|
||
}
|
||
|
||
POINT CSceneManager::GetChacterScreenPos(int nCount)
|
||
{
|
||
//return m_CharacterManager.m_CharacterScreenPositionList[nCount];
|
||
return m_CharacterManager.m_CharacterList[nCount].m_ptScreenPosition;
|
||
|
||
}
|
||
|
||
vector3 CSceneManager::GetCharacterPos(int nCount)
|
||
{
|
||
vector3 vecPos;
|
||
m_CharacterManager.m_CharacterList[nCount].m_pChrmodel->GetPosition(vecPos.x,vecPos.y,vecPos.z);
|
||
|
||
return vecPos;
|
||
}
|
||
|
||
vector3 CSceneManager::PickPointTerrain()
|
||
{
|
||
CSectorScene *pSelectSector=PickTerrain();
|
||
if(pSelectSector==NULL)
|
||
return vector3(0.0f,0.0f,0.0f);
|
||
|
||
SectorVertex *pEditSectorVertex;
|
||
pSelectSector->m_pROAMVertex->Lock(0,0,(BYTE**)&pEditSectorVertex,0);
|
||
|
||
vector3 vecTerrainPos,vecLens;
|
||
vector3 vecMousePos;
|
||
|
||
vector3 vecStart=m_vecPickRayStart;
|
||
vector3 vecDir=m_vecPickRayDir;
|
||
|
||
float fIntersection;
|
||
|
||
vector3 vecIntersectionPoint;
|
||
vecIntersectionPoint.x=-1.0f;
|
||
|
||
vector3 vecCollisionVertex[3];
|
||
|
||
matrix matTerrainTM,matTM;
|
||
matTerrainTM=pSelectSector->m_AccumulateTM;
|
||
matTM.Translation(vecStart);
|
||
matTerrainTM.Inverse(matTerrainTM);
|
||
matTM=matTM*matTerrainTM;
|
||
vecStart=matTM.GetLoc();
|
||
|
||
float fLens=100000000.0f;
|
||
bool bFound=false;
|
||
|
||
for(int cIndices=0;cIndices<pSelectSector->m_UsedIndices/3;cIndices++)
|
||
{
|
||
vecCollisionVertex[0]=pSelectSector->m_pDrawVertex[pSelectSector->m_pDrawIndices[cIndices*3+0]].v;
|
||
vecCollisionVertex[1]=pSelectSector->m_pDrawVertex[pSelectSector->m_pDrawIndices[cIndices*3+1]].v;
|
||
vecCollisionVertex[2]=pSelectSector->m_pDrawVertex[pSelectSector->m_pDrawIndices[cIndices*3+2]].v;
|
||
|
||
|
||
if(CIntersection::PolygonRay(vecStart,vecStart+100000.0f*vecDir,vecCollisionVertex,fIntersection)==1)
|
||
{
|
||
if(fLens>fIntersection)
|
||
{
|
||
vecIntersectionPoint=vecStart+vecDir*fIntersection;
|
||
fLens=fIntersection;
|
||
bFound=true;
|
||
}
|
||
}
|
||
}
|
||
vecIntersectionPoint.x+=pSelectSector->m_AccumulateTM._41;
|
||
vecIntersectionPoint.z+=pSelectSector->m_AccumulateTM._43;
|
||
pSelectSector->m_pROAMVertex->Unlock();
|
||
if(!bFound)
|
||
return vector3(0.0f,0.0f,0.0f);
|
||
return vecIntersectionPoint;
|
||
}
|
||
|
||
void CSceneManager::CharacterSoundPlay(CZ3DGeneralChrModel *pChrmodel, char *strSoundFile)
|
||
{
|
||
m_CharacterManager.CharacterSoundPlay(pChrmodel,strSoundFile);
|
||
}
|
||
|
||
void CSceneManager::CharacterHeightFix()
|
||
{
|
||
m_CharacterManager.HeightFiledOnChrFixPos();
|
||
}
|
||
|
||
void CSceneManager::LoadMap(char *strFilename)
|
||
{
|
||
//m_MapStorage.Load(strFilename);
|
||
//m_MapStorage.Load(strFilename);
|
||
m_MapStorage.Load(strFilename);
|
||
|
||
m_HeightField.m_NowPositionX=-100000000;
|
||
m_HeightField.m_NowPositionY=-100000000;
|
||
m_HeightField.m_NowTessellatePosX=-100000000;
|
||
m_HeightField.m_NowTessellatePosY=-100000000;
|
||
|
||
|
||
}
|
||
|
||
void CSceneManager::AllObjectCalcLens()
|
||
{
|
||
m_HeightField.AllObjectCalcLens();
|
||
}
|
||
|
||
int CSceneManager::GetCharacterEvent(CZ3DGeneralChrModel *pChrmodel,DWORD Event)
|
||
{
|
||
return m_CharacterManager.GetCharacterEvent(pChrmodel,Event);
|
||
}
|
||
|
||
void CSceneManager::AddDelayTimer(CZ3DGeneralChrModel *pChr, int nDelay)
|
||
{
|
||
m_CharacterManager.AddDelayTimer(pChr,nDelay);
|
||
}
|
||
|
||
void CSceneManager::AddChrLight(CZ3DGeneralChrModel *pChrmodel,vector3 vecPos, DWORD dwColor, float fLens, DWORD dwTime)
|
||
{
|
||
m_CharacterManager.AddChrLight(pChrmodel,vecPos,dwColor,fLens,dwTime);
|
||
}
|
||
|
||
void CSceneManager::PickingObjectReload()
|
||
{
|
||
if(m_PickHouseScene && m_PickObjectScene==NULL)
|
||
{
|
||
if(m_PickHouseScene->m_HouseObject->m_pOutHouseObject)
|
||
MeshObjectReload(m_PickHouseScene->m_HouseObject->m_pOutHouseObject);
|
||
if(m_PickHouseScene->m_HouseObject->m_pLodHouseObject)
|
||
MeshObjectReload(m_PickHouseScene->m_HouseObject->m_pLodHouseObject);
|
||
if(m_PickHouseScene->m_HouseObject->m_pMedHouseObject)
|
||
MeshObjectReload(m_PickHouseScene->m_HouseObject->m_pMedHouseObject);
|
||
if(m_PickHouseScene->m_HouseObject->m_pInHouseObject)
|
||
MeshObjectReload(m_PickHouseScene->m_HouseObject->m_pInHouseObject);
|
||
}
|
||
else if(m_PickObjectScene)
|
||
{
|
||
MeshObjectReload(m_PickObjectScene->m_pObject);
|
||
}
|
||
|
||
//CSceneManager::m_PickObjectScene;
|
||
}
|
||
|
||
void CSceneManager::MeshObjectReload(CMeshObject *pMesh)
|
||
{
|
||
CTexture::SetPath(OBJECTTEXTUREPATH);
|
||
char strReload[256];
|
||
for(int i=0;i<pMesh->m_pMat.num;i++)
|
||
{
|
||
if(strstr(pMesh->m_pMat[i]->m_strName,"_Reload")==NULL)
|
||
{
|
||
sprintf(strReload,"%s%s",pMesh->m_pMat[i]->m_strName," _Reload");
|
||
strcpy(pMesh->m_pMat[i]->m_strName,strReload);
|
||
}
|
||
else
|
||
{
|
||
pMesh->m_pMat[i]->m_pddTexture->Release();
|
||
}
|
||
sscanf(pMesh->m_pMat[i]->m_strName,"%s _Reload",strReload);
|
||
strcpy(pMesh->m_pMat[i]->m_strName,strReload);
|
||
pMesh->m_pMat[i]->ReadDDSTexture(pMesh->m_pMat[i]->m_pddTexture,1);
|
||
sprintf(strReload,"%s%s",pMesh->m_pMat[i]->m_strName," _Reload");
|
||
strcpy(pMesh->m_pMat[i]->m_strName,strReload);
|
||
}
|
||
pMesh->MeshReload();
|
||
}
|
||
void CSceneManager::DeleteAllEffect(){
|
||
|
||
m_EffectManager.DeleteAllEffect();
|
||
m_EffectManager.DeleteAllWorldScript();
|
||
}
|
||
void CSceneManager::DeleteAllWorldEffect() {
|
||
|
||
m_EffectManager.DeleteAllWorldScript();
|
||
|
||
}
|
||
XEFFECT CSceneManager::AddEffect(CX3DEffect *lpNewEffect)
|
||
{
|
||
m_EffectNum++;
|
||
lpNewEffect->SetEffectStart(true);
|
||
return m_EffectManager.AddEffect(lpNewEffect);
|
||
}
|
||
CEffScript *CSceneManager:: AddEffectScript (CEffScript *lpnewScript) {
|
||
return m_EffectManager.AddEffScript(lpnewScript);
|
||
}
|
||
void CSceneManager:: AddInterfaceScript (CEffScript *lpnewScript) {
|
||
m_EffectManager.AddInterfaceScript(lpnewScript);
|
||
|
||
}
|
||
void CSceneManager:: AddWorldEffect(CEffScript *lpnewScript) {
|
||
m_EffectManager.AddWorldEffScript(lpnewScript);
|
||
}
|
||
void CSceneManager::DeleteEffect(XEFFECT hEffect)
|
||
{
|
||
m_EffectNum--;
|
||
m_EffectManager.DeleteEffect(hEffect);
|
||
}
|
||
|
||
BOOL CSceneManager::EffectIsLive(XEFFECT hEffect)
|
||
{
|
||
return m_EffectManager.IsLive(hEffect);
|
||
}
|
||
|
||
void CSceneManager::DeleteEffect(CX3DEffect *del)
|
||
{
|
||
|
||
for(int i=0;i<m_EffectNum;i++) {
|
||
if(m_EffectManager.m_lstEffect[i] == del) {
|
||
DeleteEffect(i);
|
||
m_EffectNum--;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
void CSceneManager::UnPicking()
|
||
{
|
||
m_PickEffect = NULL;
|
||
m_PickHouseScene=NULL;
|
||
m_PickLightScene=NULL;
|
||
m_PickObjectScene=NULL;
|
||
m_pPickSector = NULL;
|
||
|
||
}
|
||
void CSceneManager::UnPickEffect() {
|
||
if(m_PickEffect) {
|
||
m_PickEffect->pick_index = -1;
|
||
m_PickEffect = NULL;
|
||
}
|
||
}
|
||
void CSceneManager::PickEffect(float fMx,float fMy,float fMz) {
|
||
vector3 vecPos;
|
||
float length = 0.0f;
|
||
float line_length = 0.0f;
|
||
float min = 0.0f;
|
||
float pick_range = 50.0f;
|
||
float e_dot = 0.0f;
|
||
int min_index = -1;
|
||
|
||
vector3 tmp;
|
||
// <20><><EFBFBD>ο<EFBFBD><CEBF><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ
|
||
vector3 e_Closet;
|
||
|
||
vector3 e_RayStart = m_vecPickRayStart;
|
||
vector3 e_RayEnd = e_RayStart + m_vecPickRayDir * pick_range;
|
||
|
||
vector3 e_vector1,e_vector2,e_vector3;
|
||
vector3 test_vector;
|
||
m_PickEffect = m_MapStorage.FindEffectMap(fMx,fMz);
|
||
|
||
if(m_PickEffect) {
|
||
for(int i= 0 ;i<m_PickEffect->m_vecEffectPos.num;i++) {
|
||
tmp = m_PickEffect->m_vecEffectPos[i];
|
||
e_vector1 = tmp - e_RayStart;
|
||
e_vector2 = e_RayEnd - e_RayStart;
|
||
line_length = e_vector2.GetLens();
|
||
|
||
e_vector2.Normalize();
|
||
|
||
e_dot = e_vector1 * e_vector2;
|
||
if(e_dot <=0)
|
||
e_Closet = e_RayStart;
|
||
else if(e_dot >= line_length)
|
||
e_Closet = e_RayEnd;
|
||
// <20>Ÿ<EFBFBD>
|
||
else {
|
||
e_vector3 = e_vector2 * e_dot;
|
||
e_Closet = e_vector1 + e_vector3;
|
||
}
|
||
//<2F><><EFBFBD>̿<EFBFBD><CCBF><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> vector
|
||
test_vector = tmp - e_Closet;
|
||
length = test_vector.GetLens();
|
||
|
||
if(i == 0) {
|
||
min = length;
|
||
min_index = i;
|
||
}
|
||
else if(min >= length) {
|
||
min_index = i;
|
||
min = length;
|
||
}
|
||
}//for
|
||
if(min_index >=0) {
|
||
m_PickEffect->pick_index = min_index;
|
||
}
|
||
}
|
||
|
||
|
||
// vecPos.x = fMx;
|
||
// vecPos.y = fMy;
|
||
// vecPos.z = fMz;
|
||
|
||
|
||
/*
|
||
if(m_PickEffect) {
|
||
for(int i= 0 ;i<m_PickEffect->m_vecEffectPos.num;i++) {
|
||
tmp = vecPos - m_PickEffect->m_vecEffectPos[i];
|
||
|
||
length = tmp.GetLens();
|
||
if(i == 0)
|
||
min = length;
|
||
if(min >= length)
|
||
min_index = i;
|
||
}//for
|
||
}
|
||
if(min_index >=0) {
|
||
m_PickEffect->pick_index = min_index;
|
||
}
|
||
*/
|
||
|
||
}
|
||
void CSceneManager::PickLandscapeEffect(float fPx,float fPy,float fPz,int PickMode)
|
||
{
|
||
vector3 vecPos;
|
||
|
||
vecPos.x = fPx;
|
||
vecPos.y = fPy;
|
||
vecPos.z = fPz;
|
||
|
||
|
||
if(PickMode == 0) { // vfog
|
||
float length = 0.0f;
|
||
float min = 0.0f;
|
||
int min_index = -1;
|
||
vector3 tmp;
|
||
|
||
m_PickLandscape = m_MapStorage.FindLandscapeEffect(fPx,fPz);
|
||
if(m_PickLandscape) {
|
||
for(int i = 0;i<m_PickLandscape->m_LandscapeEffect.num;i++) {
|
||
tmp = vecPos - m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos;
|
||
m_PickLandscape->m_LandscapeEffect[i].m_IntParam[1] = false;
|
||
|
||
length = tmp.GetLens();
|
||
if(i == 0)
|
||
min = length;
|
||
if(min >= length)
|
||
min_index = i;
|
||
}
|
||
}
|
||
if(min_index>=0) { // find closet landeffect
|
||
m_PickLandscape->m_LandscapeEffect[min_index].m_IntParam[1] = true;
|
||
}
|
||
}
|
||
else if(PickMode == 1) {// boid
|
||
float length = 0.0f;
|
||
float min = 0.0f;
|
||
int min_index = -1;
|
||
vector3 tmp;
|
||
|
||
m_PickLandscape = m_MapStorage.FindLandscapeEffect(fPx,fPz);
|
||
if(m_PickLandscape) {
|
||
for(int i = 0;i<m_PickLandscape->m_LandscapeEffect.num;i++) {
|
||
tmp = vecPos - m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos;
|
||
m_PickLandscape->m_LandscapeEffect[i].m_IntParam[1] = false;
|
||
|
||
length = tmp.GetLens();
|
||
if(i == 0)
|
||
min = length;
|
||
if(min >= length)
|
||
min_index = i;
|
||
}
|
||
}
|
||
if(min_index>=0) { // find closet landeffect
|
||
m_PickLandscape->m_LandscapeEffect[min_index].m_IntParam[1] = true;
|
||
}
|
||
}
|
||
else if(PickMode == 2) { //mesh
|
||
float length = 0.0f;
|
||
float min = 0.0f;
|
||
int min_index = -1;
|
||
vector3 tmp;
|
||
|
||
m_PickLandscape = m_MapStorage.FindLandscapeEffect(fPx,fPz);
|
||
if(m_PickLandscape) {
|
||
for(int i = 0;i<m_PickLandscape->m_LandscapeEffect.num;i++) {
|
||
tmp = vecPos - m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos;
|
||
m_PickLandscape->m_LandscapeEffect[i].m_IntParam[2] = false;
|
||
|
||
length = tmp.GetLens();
|
||
if(i == 0)
|
||
min = length;
|
||
if(min >= length)
|
||
min_index = i;
|
||
}
|
||
}
|
||
if(min_index>=0) { // find closet landeffect
|
||
m_PickLandscape->m_LandscapeEffect[min_index].m_IntParam[2] = true;
|
||
}
|
||
}
|
||
else if(PickMode == 3) {// wave
|
||
float length = 0.0f;
|
||
float min = 0.0f;
|
||
int min_index = -1;
|
||
vector3 tmp;
|
||
|
||
m_PickLandscape = m_MapStorage.FindLandscapeEffect(fPx,fPz);
|
||
if(m_PickLandscape) {
|
||
for(int i = 0;i<m_PickLandscape->m_LandscapeEffect.num;i++) {
|
||
tmp = vecPos - m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos;
|
||
m_PickLandscape->m_LandscapeEffect[i].m_IntParam[0] = false;
|
||
|
||
length = tmp.GetLens();
|
||
if(i == 0)
|
||
min = length;
|
||
if(min >= length)
|
||
min_index = i;
|
||
}
|
||
}
|
||
if(min_index>=0) { // find closet landeffect
|
||
m_PickLandscape->m_LandscapeEffect[min_index].m_IntParam[0] = true;
|
||
}
|
||
}
|
||
}
|
||
void CSceneManager::DeletePickingLandscapeEffect() {
|
||
CSectorScene *pSector;
|
||
|
||
if(m_PickLandscape != NULL) {
|
||
for(int i = 0;i<m_PickLandscape->m_LandscapeEffect.num;i++) {
|
||
if(m_PickLandscape->m_LandscapeEffect[i].m_nEffectMethod == 1) {
|
||
// vol-fog
|
||
if(m_PickLandscape->m_LandscapeEffect[i].m_IntParam[1] == 1) {
|
||
m_PickLandscape->m_LandscapeEffect.DelIndex(i);
|
||
break;
|
||
}
|
||
}
|
||
else if(m_PickLandscape->m_LandscapeEffect[i].m_nEffectMethod == 2) {
|
||
// boid
|
||
if(m_PickLandscape->m_LandscapeEffect[i].m_IntParam[1] == 1) {
|
||
m_PickLandscape->m_LandscapeEffect.DelIndex(i);
|
||
break;
|
||
}
|
||
}
|
||
else if(m_PickLandscape->m_LandscapeEffect[i].m_nEffectMethod == 3) {
|
||
//mesh ani
|
||
if(m_PickLandscape->m_LandscapeEffect[i].m_IntParam[2] == 1) {
|
||
m_PickLandscape->m_LandscapeEffect.DelIndex(i);
|
||
break;
|
||
}
|
||
}
|
||
else if(m_PickLandscape->m_LandscapeEffect[i].m_nEffectMethod == 4) {
|
||
// wave
|
||
if(m_PickLandscape->m_LandscapeEffect[i].m_IntParam[0] == 1) {
|
||
m_PickLandscape->m_LandscapeEffect.DelIndex(i);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if(m_PickLandscape->m_LandscapeEffect.num== 0) {
|
||
m_MapStorage.DeleteLandscapeEffect(m_PickLandscape);
|
||
}
|
||
|
||
m_PickLandscape = NULL;
|
||
pSector=PickTerrain();
|
||
pSector->GenerateLandscapeEffect();
|
||
}
|
||
|
||
}
|
||
void CSceneManager::DeletePickEffect() {
|
||
CSectorScene *pSector;
|
||
|
||
vector3 *pvecPos = GetCamera()->GetPosition();
|
||
vector3 vecPos = (*pvecPos);
|
||
|
||
pSector=PickTerrain(vecPos.x,vecPos.y,vecPos.z);
|
||
|
||
if(m_PickEffect != NULL) {
|
||
m_PickEffect->m_vecEffectPos.DelIndex(m_PickEffect->pick_index);
|
||
m_PickEffect->m_strEffectName.DelIndex(m_PickEffect->pick_index);
|
||
|
||
m_PickEffect->pick_index = -1;
|
||
m_PickEffect = NULL;
|
||
|
||
pSector->GenerateEffect();
|
||
}
|
||
|
||
}
|
||
vector3 CSceneManager::GetPickBspCenter()
|
||
{
|
||
if(m_RBspSceneManager.m_pCurrentBspScene != NULL)
|
||
{
|
||
return (m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos);
|
||
}
|
||
return vector3(0.0f,0.0f,0.0f);
|
||
}
|
||
void CSceneManager::UnPickRBspScene()
|
||
{
|
||
m_PickObjectScene = NULL;
|
||
|
||
if(m_RBspSceneManager.m_pCurrentBspScene != NULL)
|
||
{
|
||
|
||
RBspScene *pScene = m_RBspSceneManager.m_pCurrentBspScene;
|
||
int i;
|
||
for( i = 0; i < pScene->m_iLeafsNum; i++)
|
||
{
|
||
pScene->m_pLeafExs[i].UnPickEventEffect();
|
||
pScene->m_pLeafExs[i].UnPickEventObject();
|
||
pScene->m_pLeafExs[i].UnPickEventSound();
|
||
pScene->m_pLeafExs[i].UnPickLight();
|
||
pScene->m_pLeafExs[i].UnPickTrigger();
|
||
pScene->m_pLeafExs[i].UnPickR3SObject();
|
||
|
||
}
|
||
|
||
}
|
||
}
|
||
void CSceneManager::PickRBspObject(float x,float y,float z,int iPickValue)
|
||
{
|
||
if(m_RBspSceneManager.m_pCurrentBspScene != NULL)
|
||
{
|
||
D3DXVECTOR3 vecPos = D3DXVECTOR3(x,y,z);
|
||
/*
|
||
D3DXVECTOR3 vecLocal = vecPos;
|
||
D3DXMATRIX matTmp;
|
||
D3DXMATRIX matInv;
|
||
|
||
D3DXMatrixIdentity(&matTmp);
|
||
matTmp._41 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x;
|
||
matTmp._42 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y;
|
||
matTmp._43 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z;
|
||
|
||
D3DXMatrixInverse(&matInv,NULL,&matTmp);
|
||
D3DXMatrixIdentity(&matTmp);
|
||
matTmp._41 = vecLocal.x;
|
||
matTmp._42 = vecLocal.y;
|
||
matTmp._43 = vecLocal.z;
|
||
D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
|
||
vecLocal.x = matTmp._41;
|
||
vecLocal.y = matTmp._42;
|
||
vecLocal.z = matTmp._43;
|
||
|
||
int iLeaf = m_RBspSceneManager.m_pCurrentBspScene->FindLeafNode(vecLocal);
|
||
*/
|
||
|
||
int iLeaf = m_RBspSceneManager.m_pCurrentBspScene->m_iRBspLeafIndex;
|
||
int i;
|
||
int iPickIndex = -1;
|
||
float fPickLength = 0.0f;
|
||
|
||
RBspScene::RBspLeafEx *pLeaf = &(m_RBspSceneManager.m_pCurrentBspScene->m_pLeafExs[iLeaf]);
|
||
|
||
if(iPickValue == 0) // Object
|
||
{
|
||
for( i= 0; i < pLeaf->m_iEventNum[0]; i++)
|
||
{
|
||
D3DXVECTOR3 vecTmp;
|
||
float fTmp;
|
||
vecTmp = (pLeaf->m_lstObject[i]->m_vecCenter) - vecPos;
|
||
fTmp = D3DXVec3Length(&vecTmp);
|
||
if( i == 0)
|
||
{
|
||
fPickLength = fTmp;
|
||
iPickIndex = i;
|
||
}
|
||
else if(fTmp < fPickLength)
|
||
{
|
||
fPickLength = fTmp;
|
||
iPickIndex = i;
|
||
}
|
||
}
|
||
pLeaf->m_pPickEventObject = pLeaf->m_lstObject[iPickIndex];
|
||
pLeaf->m_pPickEventEffect = NULL;
|
||
pLeaf->m_pPickEventSound = NULL;
|
||
pLeaf->m_pPickLight = NULL;
|
||
pLeaf->m_pPickTrigger = NULL;
|
||
|
||
}
|
||
else if(iPickValue == 1) // Effect
|
||
{
|
||
for( i= 0; i < pLeaf->m_iEventNum[1]; i++)
|
||
{
|
||
D3DXVECTOR3 vecTmp;
|
||
float fTmp;
|
||
vecTmp = (pLeaf->m_lstEffect[i]->m_vecCenter) - vecPos;
|
||
fTmp = D3DXVec3Length(&vecTmp);
|
||
if( i == 0)
|
||
{
|
||
fPickLength = fTmp;
|
||
iPickIndex = i;
|
||
}
|
||
else if(fTmp < fPickLength)
|
||
{
|
||
fPickLength = fTmp;
|
||
iPickIndex = i;
|
||
}
|
||
}
|
||
pLeaf->m_pPickEventEffect = pLeaf->m_lstEffect[iPickIndex];
|
||
pLeaf->m_pPickEventObject = NULL;
|
||
pLeaf->m_pPickLight = NULL;
|
||
pLeaf->m_pPickEventSound = NULL;
|
||
pLeaf->m_pPickTrigger = NULL;
|
||
|
||
}
|
||
else if(iPickValue == 2) // Light
|
||
{
|
||
for( i= 0; i < pLeaf->m_iLightNum; i++)
|
||
{
|
||
D3DXVECTOR3 vecTmp;
|
||
float fTmp;
|
||
vecTmp = (pLeaf->m_lstLight[i].m_vecLight) - vecPos;
|
||
fTmp = D3DXVec3Length(&vecTmp);
|
||
if( i == 0)
|
||
{
|
||
fPickLength = fTmp;
|
||
iPickIndex = i;
|
||
}
|
||
else if(fTmp < fPickLength)
|
||
{
|
||
fPickLength = fTmp;
|
||
iPickIndex = i;
|
||
}
|
||
}
|
||
pLeaf->m_pPickLight = &(pLeaf->m_lstLight[iPickIndex]);
|
||
pLeaf->m_pPickEventEffect = NULL;
|
||
pLeaf->m_pPickEventObject = NULL;
|
||
pLeaf->m_pPickEventSound = NULL;
|
||
pLeaf->m_pPickTrigger = NULL;
|
||
|
||
}
|
||
}
|
||
}
|
||
void CSceneManager::PickRBspObjectMove(float fMx,float fMy,float fMz,float fAngle,float fAddy,int iValue,int MoveMode)
|
||
{
|
||
if(m_RBspSceneManager.m_pCurrentBspScene != NULL)
|
||
{
|
||
|
||
int iLeaf = m_RBspSceneManager.m_pCurrentBspScene->m_iRBspLeafIndex;
|
||
RBspScene::RBspLeafEx *pLeaf = &(m_RBspSceneManager.m_pCurrentBspScene->m_pLeafExs[iLeaf]);
|
||
|
||
if(iValue == 0) // Object
|
||
{
|
||
RBspScene::RBspEventObject *pObject = pLeaf->m_pPickEventObject;
|
||
|
||
if(pObject != NULL) {
|
||
if(MoveMode == 0) {// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̵<EFBFBD>
|
||
pObject->m_vecCenter.x = fMx;
|
||
pObject->m_vecCenter.z = fMz;
|
||
|
||
}
|
||
else if(MoveMode == 1) {// y <20><> <20>̵<EFBFBD>
|
||
pObject->m_vecCenter.y += fAddy;
|
||
}
|
||
}
|
||
}
|
||
else if(iValue == 1) // Effect
|
||
{
|
||
RBspScene::RBspEventEffect *pEffect = pLeaf->m_pPickEventEffect;
|
||
|
||
if(pEffect != NULL) {
|
||
if(MoveMode == 0) {// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̵<EFBFBD>
|
||
pEffect->m_vecCenter.x = fMx;
|
||
pEffect->m_vecCenter.z = fMz;
|
||
|
||
}
|
||
else if(MoveMode == 1) {// y <20><> <20>̵<EFBFBD>
|
||
pEffect->m_vecCenter.y += fAddy;
|
||
}
|
||
}
|
||
}
|
||
else if(iValue == 2) // Light
|
||
{
|
||
RBspScene::RBspLight *pLight = pLeaf->m_pPickLight;
|
||
|
||
if(pLight != NULL) {
|
||
if(MoveMode == 0) {// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̵<EFBFBD>
|
||
pLight->m_vecLight.x = fMx;
|
||
pLight->m_vecLight.z = fMz;
|
||
|
||
}
|
||
else if(MoveMode == 1) {// y <20><> <20>̵<EFBFBD>
|
||
pLight->m_vecLight.y += fAddy;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Bsp Scene Move
|
||
void CSceneManager::PickBspMove(float fMx,float fMy,float fMz,float fAngle,float fAddy,int MoveMode)
|
||
{
|
||
if(m_RBspSceneManager.m_pCurrentBspScene != NULL)
|
||
{
|
||
if(MoveMode == 0) {// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̵<EFBFBD>
|
||
float fx = fMx - m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x;
|
||
float fz = fMz - m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z;
|
||
|
||
m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x = fMx;
|
||
m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z = fMz;
|
||
m_RBspSceneManager.m_pCurrentBspScene->UpdateLeafBox(fx,0.0f,fz);
|
||
|
||
}
|
||
else if(MoveMode == 1) {// y <20><> <20>̵<EFBFBD>
|
||
m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y+=fAddy;
|
||
m_RBspSceneManager.m_pCurrentBspScene->UpdateLeafBox(0.0f,fAddy,0.0f);
|
||
}
|
||
|
||
/* m_RBspSceneManager.m_pCurrentBspScene->SetZeroPosition(m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x,
|
||
m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y,
|
||
m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z);
|
||
*/
|
||
}
|
||
else if(m_RBspSceneManager.m_iPickIndex != -1)
|
||
{
|
||
int iPick = m_RBspSceneManager.m_iPickIndex;
|
||
|
||
if(MoveMode == 0) {// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̵<EFBFBD>
|
||
float fx = fMx - m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.x;
|
||
float fz = fMz - m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.z;
|
||
|
||
m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.x = fMx;
|
||
m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.z = fMz;
|
||
m_RBspSceneManager.m_lstBspScene[iPick]->UpdateLeafBox(fx,0.0f,fz);
|
||
|
||
}
|
||
else if(MoveMode == 1) {// y <20><> <20>̵<EFBFBD>
|
||
m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.y += fAddy;
|
||
m_RBspSceneManager.m_lstBspScene[iPick]->UpdateLeafBox(0.0f,fAddy,0.0f);
|
||
}
|
||
/* m_RBspSceneManager.m_lstBspScene[iPick]->SetZeroPosition(m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.x,
|
||
m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.y,
|
||
m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.z,true);
|
||
*/
|
||
}
|
||
else
|
||
{
|
||
m_RBspSceneManager.m_lstBspScene[0]->SetZeroPosition(fMx,fMy,fMz);
|
||
|
||
}
|
||
}
|
||
|
||
|
||
void CSceneManager::PickEffectMove(float fMx,float fMy,float fMz,float fAngle,float fAddy,int MoveMode){
|
||
CSectorScene *pSector;
|
||
|
||
m_vecPickRayDir.x = 0.0f;
|
||
m_vecPickRayDir.y = -1.0f;
|
||
m_vecPickRayDir.z = 0.0f;
|
||
|
||
vector3 *pvecPos = GetCamera()->GetPosition();
|
||
vector3 vecPos = (*pvecPos);
|
||
|
||
pSector=PickTerrain(vecPos.x,vecPos.y,vecPos.z);
|
||
|
||
|
||
if(m_PickEffect) {
|
||
if(MoveMode == 0) {// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̵<EFBFBD>
|
||
m_PickEffect->m_vecEffectPos[m_PickEffect->pick_index].x = fMx;
|
||
//m_PickEffect->m_vecEffectPos.x = fMx;
|
||
m_PickEffect->m_vecEffectPos[m_PickEffect->pick_index].z = fMz;
|
||
}
|
||
else if(MoveMode == 1) {// y <20><> <20>̵<EFBFBD>
|
||
m_PickEffect->m_vecEffectPos[m_PickEffect->pick_index].y+=fAddy;
|
||
}
|
||
pSector->GenerateEffect();
|
||
}
|
||
}
|
||
void CSceneManager::PickEffectRot(float x,float y,float z,int MoveMode) {
|
||
static float xrot = 0.0f;
|
||
static float yrot = 0.0f;
|
||
static float zrot = 0.0f;
|
||
|
||
CSectorScene *pSector;
|
||
|
||
m_vecPickRayDir.x = 0.0f;
|
||
m_vecPickRayDir.y = -1.0f;
|
||
m_vecPickRayDir.z = 0.0f;
|
||
|
||
vector3 *pvecPos = GetCamera()->GetPosition();
|
||
vector3 vecPos = (*pvecPos);
|
||
|
||
pSector=PickTerrain(vecPos.x,vecPos.y,vecPos.z);
|
||
|
||
if(m_PickEffect) {
|
||
if(MoveMode == 0) {// x<><78> rot
|
||
m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].x +=x;
|
||
if(m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].x >= 360.0f) {
|
||
m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].x = m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].x - 360.0f;
|
||
}
|
||
}
|
||
else if(MoveMode == 1) {// y <20><> rot
|
||
m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].y +=y;
|
||
|
||
if(m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].y >= 360.0f) {
|
||
m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].y = m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].y - 360.0f;
|
||
}
|
||
}
|
||
else if(MoveMode == 2) { //z <20><> rot
|
||
m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].z +=z;
|
||
|
||
if(m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].z >= 360.0f) {
|
||
m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].z = m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].z - 360.0f;
|
||
}
|
||
}
|
||
pSector->GenerateEffect();
|
||
}
|
||
}
|
||
|
||
void CSceneManager::PickLandscapeEffectMove(float fMx,float fMy,float fMz,float fAngle,float fAddy,int MoveMode){
|
||
int i;
|
||
CSectorScene *pSector;
|
||
pSector=PickTerrain();
|
||
|
||
if(m_PickLandscape) {
|
||
for(i=0;i<m_PickLandscape->m_LandscapeEffect.num;i++) {
|
||
switch(m_PickLandscape->m_LandscapeEffect[i].m_nEffectMethod) {
|
||
|
||
case 1:
|
||
if(m_PickLandscape->m_LandscapeEffect[i].m_IntParam[1] == 1) {
|
||
if(MoveMode == 0) { // x,z move
|
||
m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.x =fMx;
|
||
//m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.y =fMy;
|
||
m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.z =fMz;
|
||
|
||
}
|
||
else if(MoveMode == 1) {// y axis move
|
||
m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.y +=fAddy;
|
||
}
|
||
pSector->GenerateLandscapeEffect();
|
||
}
|
||
break;
|
||
case 3:
|
||
|
||
if(m_PickLandscape->m_LandscapeEffect[i].m_IntParam[2] == 1) {
|
||
if(MoveMode == 0) { // x,z move
|
||
m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.x =fMx;
|
||
m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.y =fMy;
|
||
m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.z =fMz;
|
||
}
|
||
else if(MoveMode == 1) {// y axis move
|
||
m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.y +=fAddy;
|
||
}
|
||
else if(MoveMode == 2) {//x axis rot
|
||
m_PickLandscape->m_LandscapeEffect[i].m_Param[4] +=fAngle;
|
||
if(m_PickLandscape->m_LandscapeEffect[i].m_Param[4] >360.0f)
|
||
m_PickLandscape->m_LandscapeEffect[i].m_Param[4] = 0.0f;
|
||
pSector->GenerateLandscapeEffect();
|
||
}
|
||
else if(MoveMode == 3) {//y axis rot
|
||
m_PickLandscape->m_LandscapeEffect[i].m_Param[5] +=fAngle;
|
||
if(m_PickLandscape->m_LandscapeEffect[i].m_Param[5] >360.0f)
|
||
m_PickLandscape->m_LandscapeEffect[i].m_Param[5] = 0.0f;
|
||
pSector->GenerateLandscapeEffect();
|
||
}
|
||
else if(MoveMode == 4) {//z axis rot
|
||
m_PickLandscape->m_LandscapeEffect[i].m_Param[6] +=fAngle;
|
||
if(m_PickLandscape->m_LandscapeEffect[i].m_Param[6] >360.0f)
|
||
m_PickLandscape->m_LandscapeEffect[i].m_Param[6] = 0.0f;
|
||
pSector->GenerateLandscapeEffect();
|
||
}
|
||
}
|
||
break;
|
||
|
||
}//switch
|
||
}//for
|
||
}//if
|
||
}
|
||
|
||
void CSceneManager::CharacterMovementVector(CZ3DGeneralChrModel *pChrmodel, vector3 vecMove,float fAccelate)
|
||
{
|
||
m_CharacterManager.CharacterMovementVector(pChrmodel,vecMove,fAccelate);
|
||
}
|
||
|
||
vector3 CSceneManager::GetCharacterMovementVector(CZ3DGeneralChrModel *pChrmodel)
|
||
{
|
||
return m_CharacterManager.GetCharacterMovementVector(pChrmodel);
|
||
}
|
||
|
||
void CSceneManager::CharacterRandomPos(CZ3DGeneralChrModel *pChrmodel,int nTimer, vector3 vecRand)
|
||
{
|
||
m_CharacterManager.CharacterRandomPos(pChrmodel,nTimer,vecRand);
|
||
}
|
||
|
||
void CSceneManager::RenderGlareTexture()
|
||
{
|
||
m_pd3dDevice->EndScene();
|
||
|
||
LPDIRECT3DSURFACE8 m_pTempRenderSurface;
|
||
LPDIRECT3DSURFACE8 m_pTempRenderZBuffer;
|
||
m_pd3dDevice->GetRenderTarget(&m_pTempRenderSurface);
|
||
m_pd3dDevice->GetDepthStencilSurface(&m_pTempRenderZBuffer);
|
||
|
||
m_pd3dDevice->SetRenderTarget(m_GlareTexture.GetSurface(),m_pTempRenderZBuffer);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,FALSE);
|
||
|
||
////////////////////////////////////////////
|
||
m_pd3dDevice->BeginScene();
|
||
m_pd3dDevice->Clear(0,NULL,D3DCLEAR_TARGET,0xff000000,1.0f,0);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1,D3DTA_TEXTURE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2,D3DTA_DIFFUSE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,D3DTOP_SELECTARG2);
|
||
|
||
TLVertex pVertex[8];
|
||
float fTextureSize=128.0f;
|
||
|
||
pVertex[0].v.x=0.0f;
|
||
pVertex[1].v.x=0.0f;
|
||
pVertex[2].v.x=fTextureSize;
|
||
pVertex[3].v.x=fTextureSize;
|
||
|
||
pVertex[1].v.y=0.0f;
|
||
pVertex[3].v.y=0.0f;
|
||
pVertex[0].v.y=fTextureSize;
|
||
pVertex[2].v.y=fTextureSize;
|
||
|
||
pVertex[0].tu=0.0f;
|
||
pVertex[1].tu=0.0f;
|
||
|
||
pVertex[3].tu=1.0f;
|
||
pVertex[2].tu=1.0f;
|
||
|
||
pVertex[1].tv=0.0f;
|
||
pVertex[3].tv=0.0f;
|
||
|
||
pVertex[0].tv=1.0f;
|
||
pVertex[2].tv=1.0f;
|
||
|
||
for(int i=0;i<4;i++)
|
||
{
|
||
pVertex[i].w=0.1f;
|
||
pVertex[i].v.z=0.1f;
|
||
pVertex[i].Diffuse.c=0xff0000ff;
|
||
pVertex[i].Specular.c=0xffffffff;
|
||
}
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
|
||
m_pd3dDevice->SetTexture(1,NULL);
|
||
m_pd3dDevice->SetVertexShader(TLVERTEXFVF);
|
||
//m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
|
||
//m_CharacterManager.Render(m_pd3dDevice);
|
||
|
||
m_WeatherManager.m_SkyScene.RenderForGlare(m_pd3dDevice);
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
|
||
|
||
for(int cGlareNode=0;cGlareNode<m_GlareList.num;cGlareNode++)
|
||
{
|
||
if(m_GlareList[cGlareNode].m_bCubeEnv)
|
||
{
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR|1);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_COUNT3);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_NORMALIZENORMALS,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_LOCALVIEWER,TRUE);
|
||
|
||
m_pd3dDevice->SetTexture(1,m_DiffuseLightCubeTexture.GetTexture());
|
||
|
||
//m_pd3dDevice->SetTexture(1,m_LightCubeTexture);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,D3DTOP_SELECTARG1);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP,D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSW, D3DTADDRESS_CLAMP);
|
||
|
||
m_pd3dDevice->SetTransform(D3DTS_WORLD,m_GlareList[cGlareNode].m_matPosition);
|
||
|
||
m_GlareList[cGlareNode].m_pMeshObject->Render(m_pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX,1);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1 ,D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSW, D3DTADDRESS_WRAP);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_NORMALIZENORMALS,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_LOCALVIEWER,FALSE);
|
||
|
||
}
|
||
else
|
||
{
|
||
|
||
}
|
||
}
|
||
|
||
|
||
m_GlareList.num=0;
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
|
||
|
||
for(int ix=0;ix<m_HeightField.GetLSizeX();ix++)
|
||
{
|
||
for(int iy=0;iy<m_HeightField.GetLSizeY();iy++)
|
||
{
|
||
if( m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_MapWater)
|
||
{
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].RenderWater(m_pd3dDevice,true);
|
||
}
|
||
}
|
||
}
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
|
||
|
||
//m_CharacterManager.RenderGlare(m_pd3dDevice);
|
||
/*
|
||
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
pd3dDevice->SetRenderState( D3DRS_ALPHAREF,0xee);
|
||
*/
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
|
||
|
||
//m_WeatherManager.Render(m_pd3dDevice);
|
||
|
||
m_pd3dDevice->EndScene();
|
||
/////////////////////////////////////////////////
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,TRUE);
|
||
m_pd3dDevice->SetRenderTarget(m_pTempRenderSurface,m_pTempRenderZBuffer);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
|
||
|
||
m_pTempRenderSurface->Release();
|
||
m_pTempRenderZBuffer->Release();
|
||
|
||
|
||
m_pd3dDevice->BeginScene();
|
||
}
|
||
|
||
void CSceneManager::RenderFullSceneTextureBegin()
|
||
{
|
||
m_pd3dDevice->GetRenderTarget(&m_pTempRenderSurface);
|
||
m_pd3dDevice->GetDepthStencilSurface(&m_pTempRenderZBuffer);
|
||
|
||
m_pd3dDevice->SetRenderTarget(m_FullSceneTexture.GetSurface(),m_FullSceneTexture.GetZBuffer());
|
||
|
||
m_pd3dDevice->Clear(0,NULL,D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,m_WeatherManager.m_GF3ClareColor.c,1.0f,0);
|
||
}
|
||
|
||
void CSceneManager::RenderFullSceneTextureEnd()
|
||
{
|
||
if(m_FullSceneAnti)
|
||
return;
|
||
|
||
m_pd3dDevice->SetRenderTarget(m_pTempRenderSurface,m_pTempRenderZBuffer);
|
||
m_pTempRenderSurface->Release();
|
||
m_pTempRenderZBuffer->Release();
|
||
|
||
TLVertex pVertex[4];
|
||
|
||
pVertex[0].v.x=0.0f;
|
||
pVertex[1].v.x=0.0f;
|
||
pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
|
||
pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
|
||
|
||
pVertex[1].v.y=0.0f;
|
||
pVertex[3].v.y=0.0f;
|
||
pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
|
||
pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
|
||
|
||
static float fasdf=0.0f;
|
||
|
||
pVertex[0].tu=0.0f;
|
||
pVertex[1].tu=0.0f;
|
||
|
||
pVertex[3].tu=1.0f;
|
||
pVertex[2].tu=1.0f;
|
||
|
||
pVertex[1].tv=0.0f;
|
||
pVertex[3].tv=0.0f;
|
||
|
||
pVertex[0].tv=1.0f;
|
||
pVertex[2].tv=1.0f;
|
||
|
||
for(int i=0;i<4;i++)
|
||
{
|
||
pVertex[i].w=0.1f;
|
||
pVertex[i].v.z=0.1f;
|
||
pVertex[i].Diffuse.c=0xffffffff;
|
||
pVertex[i].Specular.c=0xffffffff;
|
||
}
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
m_pd3dDevice->SetTexture(0,m_FullSceneTexture.GetTexture());
|
||
m_pd3dDevice->SetTexture(1,NULL);
|
||
m_pd3dDevice->SetVertexShader(TLVERTEXFVF);
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
}
|
||
|
||
void CSceneManager::RenderFullSceneGlare()
|
||
{
|
||
m_GlareTexture.GenerateMipmap(m_pd3dDevice);
|
||
|
||
float fTextureSize=256.0f;
|
||
|
||
TLVertex pVertex[4];
|
||
pVertex[0].v.x=0.0f;
|
||
pVertex[1].v.x=0.0f;
|
||
pVertex[2].v.x=(float)fTextureSize;
|
||
pVertex[3].v.x=(float)fTextureSize;
|
||
|
||
pVertex[1].v.y=0.0f;
|
||
pVertex[3].v.y=0.0f;
|
||
pVertex[0].v.y=(float)fTextureSize;
|
||
pVertex[2].v.y=(float)fTextureSize;
|
||
|
||
static float fasdf=0.0f;
|
||
|
||
pVertex[0].tu=0.0f;
|
||
pVertex[1].tu=0.0f;
|
||
|
||
pVertex[3].tu=1.0f;
|
||
pVertex[2].tu=1.0f;
|
||
|
||
pVertex[1].tv=0.0f;
|
||
pVertex[3].tv=0.0f;
|
||
|
||
pVertex[0].tv=1.0f;
|
||
pVertex[2].tv=1.0f;
|
||
|
||
for(int i=0;i<4;i++)
|
||
{
|
||
pVertex[i].w=0.1f;
|
||
pVertex[i].v.z=0.1f;
|
||
pVertex[i].Diffuse.c=0xffffffff;
|
||
pVertex[i].Specular.c=0x0;
|
||
}
|
||
|
||
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_COLOROP, D3DTOP_DISABLE);
|
||
|
||
m_pd3dDevice->SetTexture(1,NULL);
|
||
m_pd3dDevice->SetVertexShader(TLVERTEXFVF);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,D3DBLEND_ONE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND,D3DBLEND_ONE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE);
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
|
||
|
||
m_pd3dDevice->EndScene();
|
||
|
||
m_GlareCompositeTexture.Begin(m_pd3dDevice);
|
||
|
||
m_pd3dDevice->Clear(0, NULL, D3DCLEAR_ZBUFFER|D3DCLEAR_TARGET,0x0,1.0f, 0);
|
||
|
||
m_pd3dDevice->BeginScene();
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
color VertexColor;
|
||
|
||
for(int cTexture=1;cTexture<m_GlareTexture.GetTextureCount();cTexture++)
|
||
//for(int cTexture=0;cTexture<1;cTexture++)
|
||
{
|
||
VertexColor.r=(unsigned char)(255.0f/((float)m_GlareTexture.GetTextureCount()-1));
|
||
//VertexColor.r=0x80;
|
||
//VertexColor.r=0xff;
|
||
VertexColor.a=VertexColor.b=VertexColor.g=VertexColor.r;
|
||
VertexColor.a=255;
|
||
////////
|
||
pVertex[0].Diffuse.c=pVertex[1].Diffuse.c=pVertex[2].Diffuse.c=pVertex[3].Diffuse.c
|
||
=VertexColor.c;
|
||
////////
|
||
m_pd3dDevice->SetTexture(0,m_GlareTexture.GetTexture(cTexture));
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
}
|
||
|
||
m_pd3dDevice->EndScene();
|
||
m_GlareCompositeTexture.End(m_pd3dDevice);
|
||
|
||
m_pd3dDevice->BeginScene();
|
||
|
||
if(m_FullSceneAnti)
|
||
{
|
||
pVertex[2].v.x=(float)m_ScreenSize-3;
|
||
pVertex[3].v.x=(float)m_ScreenSize-3;
|
||
|
||
pVertex[0].v.y=(float)m_ScreenSize-3;
|
||
pVertex[2].v.y=(float)m_ScreenSize-3;
|
||
}
|
||
else
|
||
{
|
||
pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx-3;
|
||
pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx-3;
|
||
|
||
pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy-3;
|
||
pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy-3;
|
||
}
|
||
|
||
pVertex[0].Diffuse.c=pVertex[1].Diffuse.c=pVertex[2].Diffuse.c=pVertex[3].Diffuse.c
|
||
=0xffaaaaaa;
|
||
|
||
m_pd3dDevice->SetTexture(0,m_GlareCompositeTexture.GetTexture());
|
||
//m_pd3dDevice->SetTexture(0,m_GlareTexture.GetTexture(2));
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,D3DBLEND_ONE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND,D3DBLEND_ONE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE);
|
||
|
||
pVertex[0].Diffuse.c=pVertex[1].Diffuse.c=pVertex[2].Diffuse.c=pVertex[3].Diffuse.c
|
||
=0xffffffff;
|
||
|
||
m_pd3dDevice->SetTexture(0,m_SpecularGlareTexture.GetTexture());
|
||
//m_pd3dDevice->SetTexture(0,m_GlareTexture.GetTexture(2));
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
|
||
//m_SmoothGlareTexture.GenerateGlareTexture(m_pd3dDevice,m_SpecularGlareTexture.GetTexture(),);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE);
|
||
|
||
pVertex[0].Diffuse.c=pVertex[1].Diffuse.c=pVertex[2].Diffuse.c=pVertex[3].Diffuse.c
|
||
=0xff555555;
|
||
|
||
m_pd3dDevice->SetTexture(0,m_SmoothGlareTexture.GetTexture());
|
||
//m_pd3dDevice->SetTexture(0,m_GlareTexture.GetTexture(2));
|
||
m_pd3dDevice->SetTexture(1,NULL);
|
||
m_pd3dDevice->SetVertexShader(TLVERTEXFVF);
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
|
||
/*
|
||
for(int ix=0;ix<30;ix++)
|
||
{
|
||
for(int iy=0;iy<1;iy++)
|
||
{
|
||
pVertex[0].v.x=0.0f+ix-15.0f;
|
||
pVertex[1].v.x=0.0f+ix-15.0f;
|
||
pVertex[2].v.x=(float)fTextureSize+ix-15.0f;
|
||
pVertex[3].v.x=(float)fTextureSize+ix-15.0f;
|
||
|
||
pVertex[1].v.y=0.0f+iy;
|
||
pVertex[3].v.y=0.0f+iy;
|
||
pVertex[0].v.y=(float)fTextureSize+iy;
|
||
pVertex[2].v.y=(float)fTextureSize+iy;
|
||
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
}
|
||
}
|
||
*/
|
||
|
||
////////////////////////
|
||
|
||
//m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
|
||
}
|
||
|
||
void CSceneManager::RenderFullSceneAnti()
|
||
{
|
||
if(!m_FullSceneAnti)
|
||
return;
|
||
|
||
m_pd3dDevice->SetRenderTarget(m_pTempRenderSurface,m_pTempRenderZBuffer);
|
||
m_pTempRenderSurface->Release();
|
||
m_pTempRenderZBuffer->Release();
|
||
|
||
TLVertex pVertex[4];
|
||
|
||
pVertex[0].v.x=0.0f;
|
||
pVertex[1].v.x=0.0f;
|
||
pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
|
||
pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
|
||
|
||
pVertex[1].v.y=0.0f;
|
||
pVertex[3].v.y=0.0f;
|
||
pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
|
||
pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
|
||
|
||
pVertex[0].tu=0.0f;
|
||
pVertex[1].tu=0.0f;
|
||
|
||
pVertex[3].tu=1.0f;
|
||
pVertex[2].tu=1.0f;
|
||
|
||
pVertex[1].tv=0.0f;
|
||
pVertex[3].tv=0.0f;
|
||
|
||
pVertex[0].tv=1.0f;
|
||
pVertex[2].tv=1.0f;
|
||
|
||
for(int i=0;i<4;i++)
|
||
{
|
||
pVertex[i].w=0.1f;
|
||
pVertex[i].v.z=0.1f;
|
||
pVertex[i].Diffuse.c=0xffffffff;
|
||
pVertex[i].Specular.c=0xffffffff;
|
||
}
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
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_COLOROP, D3DTOP_DISABLE);
|
||
|
||
m_pd3dDevice->SetTexture(1,NULL);
|
||
m_pd3dDevice->SetVertexShader(TLVERTEXFVF);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,D3DBLEND_ONE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND,D3DBLEND_ONE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE);
|
||
|
||
color VertexColor;
|
||
|
||
for(int cTexture=0;cTexture<9;cTexture++)
|
||
{
|
||
VertexColor.r=(unsigned char)(32.0f/(float)8.0f);
|
||
VertexColor.a=VertexColor.b=VertexColor.g=VertexColor.r;
|
||
VertexColor.a=255;
|
||
////////
|
||
pVertex[0].Diffuse.c=pVertex[1].Diffuse.c=pVertex[2].Diffuse.c=pVertex[3].Diffuse.c
|
||
=VertexColor.c;
|
||
////////
|
||
m_pd3dDevice->SetTexture(0,m_FullSceneTexture.GetTexture());
|
||
|
||
switch(cTexture)
|
||
{
|
||
case 0:
|
||
pVertex[0].Diffuse.c=pVertex[1].Diffuse.c=pVertex[2].Diffuse.c=pVertex[3].Diffuse.c
|
||
=0xffeeeeee;
|
||
pVertex[0].v.x=0.0f;
|
||
pVertex[1].v.x=0.0f;
|
||
pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
|
||
pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
|
||
pVertex[1].v.y=0.0f;
|
||
pVertex[3].v.y=0.0f;
|
||
pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
|
||
pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
|
||
break;
|
||
case 1:
|
||
pVertex[0].v.x=-1;
|
||
pVertex[1].v.x=-1;
|
||
pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx-1;
|
||
pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx-1;
|
||
pVertex[1].v.y=-1;
|
||
pVertex[3].v.y=-1;
|
||
pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy-1;
|
||
pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy-1;
|
||
break;
|
||
case 2:
|
||
pVertex[0].v.x=0;
|
||
pVertex[1].v.x=0;
|
||
pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
|
||
pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
|
||
pVertex[1].v.y=-1;
|
||
pVertex[3].v.y=-1;
|
||
pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy-1;
|
||
pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy-1;
|
||
break;
|
||
case 3:
|
||
pVertex[0].v.x=1;
|
||
pVertex[1].v.x=1;
|
||
pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx+1;
|
||
pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx+1;
|
||
pVertex[1].v.y=-1;
|
||
pVertex[3].v.y=-1;
|
||
pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy-1;
|
||
pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy-1;
|
||
break;
|
||
////////////
|
||
case 4:
|
||
pVertex[0].v.x=-1;
|
||
pVertex[1].v.x=-1;
|
||
pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx-1;
|
||
pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx-1;
|
||
pVertex[1].v.y=0;
|
||
pVertex[3].v.y=0;
|
||
pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
|
||
pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
|
||
break;
|
||
case 5:
|
||
pVertex[0].v.x=1;
|
||
pVertex[1].v.x=1;
|
||
pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx+1;
|
||
pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx+1;
|
||
pVertex[1].v.y=0;
|
||
pVertex[3].v.y=0;
|
||
pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
|
||
pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
|
||
break;
|
||
///
|
||
case 6:
|
||
pVertex[0].v.x=-1;
|
||
pVertex[1].v.x=-1;
|
||
pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx-1;
|
||
pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx-1;
|
||
pVertex[1].v.y=1;
|
||
pVertex[3].v.y=1;
|
||
pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy+1;
|
||
pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy+1;
|
||
break;
|
||
case 7:
|
||
pVertex[0].v.x=0;
|
||
pVertex[1].v.x=0;
|
||
pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
|
||
pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
|
||
pVertex[1].v.y=1;
|
||
pVertex[3].v.y=1;
|
||
pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy+1;
|
||
pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy+1;
|
||
break;
|
||
case 8:
|
||
pVertex[0].v.x=1;
|
||
pVertex[1].v.x=1;
|
||
pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx+1;
|
||
pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx+1;
|
||
pVertex[1].v.y=1;
|
||
pVertex[3].v.y=1;
|
||
pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy+1;
|
||
pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy+1;
|
||
break;
|
||
|
||
}
|
||
|
||
|
||
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
}
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
|
||
/*
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
*/
|
||
/*
|
||
m_pd3dDevice->SetTexture(0,m_FullSceneTexture.GetTexture());
|
||
m_pd3dDevice->SetTexture(1,NULL);
|
||
m_pd3dDevice->SetVertexShader(TLVERTEXFVF);
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
*/
|
||
}
|
||
|
||
void CSceneManager::RenderSpecularGlareTexture()
|
||
{
|
||
m_pd3dDevice->EndScene();
|
||
|
||
LPDIRECT3DSURFACE8 m_pTempRenderSurface;
|
||
LPDIRECT3DSURFACE8 m_pTempRenderZBuffer;
|
||
m_pd3dDevice->GetRenderTarget(&m_pTempRenderSurface);
|
||
m_pd3dDevice->GetDepthStencilSurface(&m_pTempRenderZBuffer);
|
||
|
||
m_pd3dDevice->SetRenderTarget(m_SpecularGlareTexture.GetSurface(),m_pTempRenderZBuffer);
|
||
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,FALSE);
|
||
|
||
////////////////////////////////////////////
|
||
m_pd3dDevice->BeginScene();
|
||
m_pd3dDevice->Clear(0,NULL,D3DCLEAR_TARGET,0xff000000,1.0f,0);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1,D3DTA_TEXTURE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2,D3DTA_DIFFUSE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,D3DTOP_SELECTARG2);
|
||
|
||
TLVertex pVertex[8];
|
||
float fTextureSize=128.0f;
|
||
|
||
pVertex[0].v.x=0.0f;
|
||
pVertex[1].v.x=0.0f;
|
||
pVertex[2].v.x=fTextureSize;
|
||
pVertex[3].v.x=fTextureSize;
|
||
|
||
pVertex[1].v.y=0.0f;
|
||
pVertex[3].v.y=0.0f;
|
||
pVertex[0].v.y=fTextureSize;
|
||
pVertex[2].v.y=fTextureSize;
|
||
|
||
pVertex[0].tu=0.0f;
|
||
pVertex[1].tu=0.0f;
|
||
|
||
pVertex[3].tu=1.0f;
|
||
pVertex[2].tu=1.0f;
|
||
|
||
pVertex[1].tv=0.0f;
|
||
pVertex[3].tv=0.0f;
|
||
|
||
pVertex[0].tv=1.0f;
|
||
pVertex[2].tv=1.0f;
|
||
|
||
for(int i=0;i<4;i++)
|
||
{
|
||
pVertex[i].w=0.1f;
|
||
pVertex[i].v.z=0.1f;
|
||
pVertex[i].Diffuse.c=0xff0000ff;
|
||
pVertex[i].Specular.c=0xffffffff;
|
||
}
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
|
||
m_pd3dDevice->SetTexture(1,NULL);
|
||
m_pd3dDevice->SetVertexShader(TLVERTEXFVF);
|
||
//m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
|
||
|
||
//m_CharacterManager.Render(m_pd3dDevice);
|
||
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
|
||
|
||
m_CharacterManager.RenderGlare(m_pd3dDevice);
|
||
/*
|
||
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
pd3dDevice->SetRenderState( D3DRS_ALPHAREF,0xee);
|
||
*/
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
|
||
|
||
//m_WeatherManager.Render(m_pd3dDevice);
|
||
|
||
m_pd3dDevice->EndScene();
|
||
/////////////////////////////////////////////////
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,TRUE);
|
||
m_pd3dDevice->SetRenderTarget(m_pTempRenderSurface,m_pTempRenderZBuffer);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
|
||
|
||
m_pTempRenderSurface->Release();
|
||
m_pTempRenderZBuffer->Release();
|
||
|
||
|
||
m_pd3dDevice->BeginScene();
|
||
}
|
||
|
||
vector3 CSceneManager::PickMousePos(int nMx, int nMy)
|
||
{
|
||
//<2F>̰<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>̴<EFBFBD>.. <20><><EFBFBD><EFBFBD><EFBFBD>Ͻñ<CFBD>..!!!!!!!!!!!!!!
|
||
|
||
PickMakeRay(nMx,nMy,BaseGraphicsLayer::m_lScreenSx,BaseGraphicsLayer::m_lScreenSy);
|
||
|
||
CSectorScene *pSector;
|
||
|
||
SectorVertex *pDrawVertex;
|
||
WORD *pDrawIndices;
|
||
|
||
vector3 vecStart,vecEnd;
|
||
vector3 vecDirection;
|
||
|
||
vecStart=m_vecPickRayStart;
|
||
vecDirection=m_vecPickRayDir;
|
||
vecDirection.Normalize();
|
||
vecEnd=vecStart+vecDirection*100000.0f;
|
||
vecStart=vecStart+vecDirection*100.0f;
|
||
vector3 vecTargetPosition;
|
||
|
||
float fInterval,fMinInterval=100000.0f;
|
||
|
||
vector3 vecPoly[3];
|
||
|
||
vecTargetPosition=vector3(-1000000000.0f,-100000000000.0f,-100000000.0f);
|
||
|
||
vector3 vecMaxBox,vecMinBox;
|
||
|
||
for(int ix=0;ix<m_HeightField.GetLSizeX();ix++)
|
||
{
|
||
for(int iy=0;iy<m_HeightField.GetLSizeY();iy++)
|
||
{
|
||
vecMinBox.x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.y=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_vecMinBox.y;
|
||
vecMaxBox.y=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_vecMaxBox.y;
|
||
|
||
vecMinBox.z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].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)
|
||
{
|
||
|
||
}
|
||
else
|
||
{
|
||
continue;
|
||
}
|
||
|
||
pSector=&m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()];
|
||
pSector->m_pROAMVertex;
|
||
pSector->m_pROAMIndices;
|
||
|
||
//m_UsedVertex,m_UsedIndices/3;
|
||
|
||
pSector->m_pROAMVertex->Lock(0,0,(BYTE**)&pDrawVertex,0);
|
||
pSector->m_pROAMIndices->Lock(0,(SECTORSX-1)*(SECTORSY-1)*ROAMBUFFERSIZE*sizeof(WORD),(BYTE**)&pDrawIndices,0);
|
||
|
||
for(int cPoly=0;cPoly<pSector->m_UsedIndices/3;cPoly++)
|
||
{
|
||
vecPoly[0]=pDrawVertex[pDrawIndices[cPoly*3+0]].v+pSector->m_AccumulateTM.GetLoc();
|
||
vecPoly[1]=pDrawVertex[pDrawIndices[cPoly*3+1]].v+pSector->m_AccumulateTM.GetLoc();
|
||
vecPoly[2]=pDrawVertex[pDrawIndices[cPoly*3+2]].v+pSector->m_AccumulateTM.GetLoc();
|
||
|
||
if(CIntersection::PolygonRay(vecStart,vecEnd,vecPoly,fInterval))
|
||
{
|
||
if(fInterval <= fMinInterval)
|
||
{
|
||
fMinInterval=fInterval;
|
||
vecTargetPosition=vecStart+vecDirection*fMinInterval;
|
||
}
|
||
}
|
||
}
|
||
pSector->m_pROAMVertex->Unlock();
|
||
pSector->m_pROAMIndices->Unlock();
|
||
}
|
||
}
|
||
|
||
///////////////////////////////
|
||
//Picking In Building
|
||
///////////////////////////////
|
||
List<vector3> vecPolyList;
|
||
for(ix=0;ix<m_HeightField.GetLSizeX();ix++)
|
||
{
|
||
for(int iy=0;iy<m_HeightField.GetLSizeY();iy++)
|
||
{
|
||
vecMinBox.x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41;
|
||
vecMaxBox.x=vecMinBox.x+SECTORSIZE;
|
||
|
||
vecMinBox.y=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_vecMinBox.y;
|
||
vecMaxBox.y=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_vecMaxBox.y;
|
||
|
||
vecMinBox.z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].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)
|
||
{
|
||
|
||
}
|
||
else
|
||
{
|
||
continue;
|
||
}
|
||
|
||
//GetPickHousePoly(vector3 vecStart,vector3 vecEnd,List<vector3> &vecPolyList)
|
||
m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].GetPickHousePoly(vecStart,vecEnd,vecPolyList);
|
||
//GetInHouseShadowPoly(vecEnd,vecPolyList,vecStart);
|
||
|
||
}
|
||
}
|
||
if(m_CharacterManager.m_CharacterList.num==0)
|
||
return vecTargetPosition;
|
||
|
||
vector3 vecChrPos;
|
||
|
||
m_CharacterManager.m_CharacterList[0].m_pChrmodel->GetPosition(vecChrPos);
|
||
|
||
vecChrPos.y;
|
||
|
||
vector3 vecCheckPoly[3];
|
||
float fInterLens;
|
||
float fMaxInterLens=1000000000.0f;
|
||
vecDirection=vecEnd-vecStart;
|
||
vecDirection.Normalize();
|
||
vector3 vecPlaneNormal;
|
||
|
||
|
||
|
||
|
||
|
||
for(int cPoly=0;cPoly<vecPolyList.num;cPoly+=3)
|
||
{
|
||
vecCheckPoly[0]=vecPolyList[cPoly+0];
|
||
vecCheckPoly[1]=vecPolyList[cPoly+1];
|
||
vecCheckPoly[2]=vecPolyList[cPoly+2];
|
||
|
||
vecPlaneNormal=(vecCheckPoly[0]-vecCheckPoly[1])^(vecCheckPoly[2]-vecCheckPoly[1]);
|
||
vecPlaneNormal.Normalize();
|
||
|
||
if(fabsf(vecPlaneNormal.y) >= fabsf(vecPlaneNormal.x) && fabsf(vecPlaneNormal.y) >= fabsf(vecPlaneNormal.z))
|
||
{
|
||
if(CIntersection::PolygonRay(vecStart,vecEnd,vecCheckPoly,fInterLens))
|
||
{
|
||
vector3 vecTarPos=vecStart+fInterLens*vecDirection;
|
||
|
||
if(fabsf(vecChrPos.y-vecTarPos.y) < fMaxInterLens)
|
||
{
|
||
vecTargetPosition=vecStart+fInterLens*vecDirection;
|
||
fMaxInterLens=fabsf(vecChrPos.y-vecTarPos.y);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return vecTargetPosition;
|
||
}
|
||
|
||
CollisionType CSceneManager::GetCharacterCollisionType(CZ3DGeneralChrModel *pChrmodel)
|
||
{
|
||
return m_CharacterManager.GetCharacterCollisionType(pChrmodel);
|
||
}
|
||
|
||
void CSceneManager::BaseGraphicsDataLoad(char *strZoneName)
|
||
{
|
||
if(strcmp(strZoneName,"")==0)
|
||
{
|
||
if(CGrassScene::m_NormalTexture==NULL)
|
||
{
|
||
CTexture::SetPath(NATURETEXTUREPATH);
|
||
CGrassScene::m_NormalTexture=new CTexture();
|
||
CGrassScene::m_NormalTexture->Load("grass.dds");
|
||
}
|
||
|
||
CTexture::SetPath(TERRAINTEXTUREPATH);
|
||
/*
|
||
m_TerrainTexture[0].Load("hig0.dds");
|
||
m_TerrainTexture[1].Load("hig1.dds");
|
||
m_TerrainTexture[2].Load("hig2.dds");
|
||
m_TerrainTexture[3].Load("hig3.dds");
|
||
|
||
m_TerrainTexture[4].Load("med0.dds");
|
||
m_TerrainTexture[5].Load("med1.dds");
|
||
m_TerrainTexture[6].Load("med2.dds");
|
||
m_TerrainTexture[7].Load("med3.dds");
|
||
|
||
m_TerrainTexture[8].Load("low0.dds");
|
||
m_TerrainTexture[9].Load("low1.dds");
|
||
m_TerrainTexture[10].Load("low2.dds");
|
||
m_TerrainTexture[11].Load("low3.dds");
|
||
*/
|
||
CSectorScene::m_DetailTexture.Load("detail.dds");
|
||
|
||
if(CRenderOption::m_RangeGrassRender)
|
||
{
|
||
CTexture::SetPath(NATURETEXTUREPATH);
|
||
|
||
CSectorScene::m_LODGrassTexture.Load("LODGrass.dds");
|
||
|
||
CSectorScene::m_GrassRangeTexture=new CTexture();
|
||
CSectorScene::m_GrassRangeTexture->Load("GrassRange.dds");
|
||
}
|
||
|
||
CTexture::SetPath(NATURETEXTUREPATH);
|
||
CSkyScene::m_CloudTexture.Load("Clouds.dds");
|
||
// <20><><EFBFBD><EFBFBD> Rain <20>߰<EFBFBD>
|
||
CSkyScene::m_LightLayerTexture[0].Load("lightning.dds");
|
||
CSkyScene::m_LightLayerTexture[1].Load("lightning1.dds");
|
||
CSkyScene::m_LightLayerTexture[2].Load("lightning2.dds");
|
||
|
||
|
||
if(CTreeScene::m_NormalTreeMesh[0]==NULL)
|
||
{
|
||
CTexture::SetPath(OBJECTTEXTUREPATH);
|
||
CSceneManager::m_MeshObjectContainer.SetPath(TREEOBJECTPATH);
|
||
|
||
char strName[256];
|
||
for(int i=0;i<MAX_TREEKIND;i++)
|
||
{
|
||
sprintf(strName,"NormalTree%d.R3S",i+1);
|
||
CTreeScene::m_NormalTreeMesh[i]=CSceneManager::m_MeshObjectContainer.GetMeshObject(strName);
|
||
if(CRenderOption::m_TreeAnimation)
|
||
CTreeScene::m_NormalTreeMesh[i]->ConvertTree();
|
||
else
|
||
CTreeScene::m_NormalTreeMesh[i]->ConvertNormal();
|
||
if(i+1<10)
|
||
sprintf(strName,"tree0%d_lod_fr.R3S",i+1);
|
||
else
|
||
sprintf(strName,"tree%d_lod_fr.R3S",i+1);
|
||
|
||
CTreeScene::m_NormalTreeMeshLOD[i]=CSceneManager::m_MeshObjectContainer.GetMeshObject(strName);
|
||
if(CRenderOption::m_TreeAnimation)
|
||
CTreeScene::m_NormalTreeMeshLOD[i]->ConvertTree();
|
||
else
|
||
CTreeScene::m_NormalTreeMeshLOD[i]->ConvertNormal();
|
||
}
|
||
/*
|
||
CTreeScene::m_NormalTreeLeaves[0]=CSceneManager::m_MeshObjectContainer.GetMeshObject("leaves.R3S");
|
||
CTreeScene::m_NormalTreeLeaves[0]->ConvertTree();
|
||
CTreeScene::m_NormalTreeTrunk[0]=CSceneManager::m_MeshObjectContainer.GetMeshObject("trunk.R3S");
|
||
CTreeScene::m_NormalTreeTrunk[0]->ConvertTree();
|
||
*/
|
||
|
||
}
|
||
m_WeatherManager.Load();
|
||
///////
|
||
char strTableName[256] = {0,};
|
||
char strBuffer[256] = {0,};
|
||
char *strPtr = NULL;
|
||
strcpy(strTableName,WEATHERPATH);
|
||
strPtr = strrchr(strTableName,'.');
|
||
strPtr++;
|
||
(*strPtr) = 't';
|
||
strPtr++;
|
||
(*strPtr) = 'a';
|
||
strPtr++;
|
||
(*strPtr) = 'b';
|
||
strPtr++;
|
||
(*strPtr) = 'l';
|
||
strPtr++;
|
||
(*strPtr) = 'e';
|
||
strPtr++;
|
||
(*strPtr) = 0;
|
||
|
||
FILE *fp = fopen(strTableName,"rt");
|
||
if(fp)
|
||
{
|
||
|
||
int *iPtr;
|
||
int iPtrNum;
|
||
char *str;
|
||
fgets(strBuffer,256,fp);
|
||
iPtrNum = atoi(strBuffer);
|
||
iPtr = new int[iPtrNum];
|
||
memset(strBuffer,0,sizeof(char) * 256);
|
||
fgets(strBuffer,256,fp);
|
||
int iNum;
|
||
|
||
for(iNum = 0; iNum < iPtrNum; iNum++)
|
||
{
|
||
if(iNum == 0)
|
||
str = strtok(strBuffer," \n");
|
||
else
|
||
str = strtok(NULL," \n");
|
||
iPtr[iNum] = atoi(str);
|
||
}
|
||
|
||
fclose(fp);
|
||
|
||
m_WeatherManager.LoadSubTable(iPtr,iPtrNum);
|
||
delete[] iPtr;
|
||
|
||
}
|
||
//////
|
||
}
|
||
else
|
||
{
|
||
// 03.03.04 <20><> <20><><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> culling <20>ٸ<EFBFBD><D9B8><EFBFBD> <20><><EFBFBD>ش<EFBFBD> (Zone5)
|
||
// Init Zone Value
|
||
char strSetPath[256] = {0};
|
||
|
||
m_ZoneInfoData.m_bZoneInfo = false;
|
||
memset(m_ZoneInfoData.m_fZoneInfo,0,sizeof(float) * 30);
|
||
memset(m_ZoneInfoData.m_iZoneInfo,0,sizeof(int) * 30);
|
||
|
||
if(CRenderOption::LoadZoneInfo(&m_ZoneInfoData))
|
||
{
|
||
// Int 0 : weather time
|
||
// 1 : House Cull
|
||
// 2 : Object Cull
|
||
// 3 : Effect Cull
|
||
// 4 : Path Setting
|
||
|
||
// float 0 1 2 ->map min size
|
||
// 3 4 5 ->map max size
|
||
// 6 7 ->map Y Bound
|
||
SetWeatherTime(m_ZoneInfoData.m_iZoneInfo[0]);
|
||
m_HeightField.SetHouseCulling((m_ZoneInfoData.m_iZoneInfo[1]) ? true : false);
|
||
m_HeightField.SetObjectCulling((m_ZoneInfoData.m_iZoneInfo[2]) ? true : false);
|
||
m_HeightField.SetEffectCulling((m_ZoneInfoData.m_iZoneInfo[3]) ? true : false);
|
||
// Map Size Setting
|
||
SetMapSize(vector3(m_ZoneInfoData.m_fZoneInfo[0],m_ZoneInfoData.m_fZoneInfo[1],m_ZoneInfoData.m_fZoneInfo[2]),
|
||
vector3(m_ZoneInfoData.m_fZoneInfo[3],m_ZoneInfoData.m_fZoneInfo[4],m_ZoneInfoData.m_fZoneInfo[5]));
|
||
// Zone Y Bound
|
||
m_CollisionDetection.SetZoneBound(m_ZoneInfoData.m_fZoneInfo[6],m_ZoneInfoData.m_fZoneInfo[7]);
|
||
|
||
if(m_ZoneInfoData.m_iZoneInfo[4] != 0) {
|
||
sprintf(strSetPath,"Zone%d",m_ZoneInfoData.m_iZoneInfo[4]);
|
||
}
|
||
}
|
||
else {
|
||
m_HeightField.SetHouseCulling(true);
|
||
m_HeightField.SetObjectCulling(true);
|
||
m_HeightField.SetEffectCulling(true);
|
||
m_CollisionDetection.SetZoneBound(-123.0f,-123.0f);
|
||
}
|
||
if(strlen(strSetPath) > 1) { // <20><> path Setting
|
||
sprintf(WEATHERPATH,"%s\\WeatherColorTable_%s.dat",m_SceneManagerPath,strZoneName);
|
||
sprintf(TREEOBJECTPATH,"%s\\Objects\\NatureObject\\%s\\",m_SceneManagerPath,strSetPath);
|
||
sprintf(MAPDATAPATH,"%s\\MapData\\%s",m_SceneManagerPath,strZoneName);
|
||
if(CRenderOption::m_TextureMethod)
|
||
{
|
||
sprintf(NATURETEXTUREPATH,"%s\\Texture\\NatureObject\\%s",m_SceneManagerPath,strSetPath);
|
||
sprintf(WIDETEXTUREPATH,"%s\\Texture\\WideTexture\\%s",m_SceneManagerPath,strZoneName);
|
||
sprintf(TERRAINTEXTUREPATH,"%s\\Texture\\Terrain\\%s",m_SceneManagerPath,strSetPath);
|
||
sprintf(UNSHADOWWIDETEXTUREPATH,"%s\\Texture\\UnShadowWideTexture\\%s",m_SceneManagerPath,strSetPath);
|
||
|
||
|
||
}
|
||
else
|
||
{
|
||
sprintf(NATURETEXTUREPATH,"%s\\LowTexture\\NatureObject\\%s",m_SceneManagerPath,strSetPath);
|
||
sprintf(WIDETEXTUREPATH,"%s\\LowTexture\\WideTexture\\%s",m_SceneManagerPath,strZoneName);
|
||
sprintf(TERRAINTEXTUREPATH,"%s\\LowTexture\\Terrain\\%s",m_SceneManagerPath,strSetPath);
|
||
sprintf(UNSHADOWWIDETEXTUREPATH,"%s\\Texture\\UnShadowWideTexture\\%s",m_SceneManagerPath,strSetPath);
|
||
}
|
||
|
||
}
|
||
else {
|
||
sprintf(WEATHERPATH,"%s\\WeatherColorTable_%s.dat",m_SceneManagerPath,strZoneName);
|
||
sprintf(TREEOBJECTPATH,"%s\\Objects\\NatureObject\\%s\\",m_SceneManagerPath,strZoneName);
|
||
sprintf(MAPDATAPATH,"%s\\MapData\\%s",m_SceneManagerPath,strZoneName);
|
||
if(strstr(strZoneName,"Zone8") != NULL) // Zone 8 Setting
|
||
MAX_OBJECTVIEWRANBE *= 2.0f;
|
||
|
||
if(CRenderOption::m_TextureMethod)
|
||
{
|
||
sprintf(NATURETEXTUREPATH,"%s\\Texture\\NatureObject\\%s",m_SceneManagerPath,strZoneName);
|
||
sprintf(WIDETEXTUREPATH,"%s\\Texture\\WideTexture\\%s",m_SceneManagerPath,strZoneName);
|
||
sprintf(UNSHADOWWIDETEXTUREPATH,"%s\\Texture\\UnShadowWideTexture\\%s",m_SceneManagerPath,strZoneName);
|
||
sprintf(TERRAINTEXTUREPATH,"%s\\Texture\\Terrain\\%s",m_SceneManagerPath,strZoneName);
|
||
}
|
||
else
|
||
{
|
||
sprintf(NATURETEXTUREPATH,"%s\\LowTexture\\NatureObject\\%s",m_SceneManagerPath,strZoneName);
|
||
sprintf(WIDETEXTUREPATH,"%s\\LowTexture\\WideTexture\\%s",m_SceneManagerPath,strZoneName);
|
||
sprintf(TERRAINTEXTUREPATH,"%s\\LowTexture\\Terrain\\%s",m_SceneManagerPath,strZoneName);
|
||
sprintf(UNSHADOWWIDETEXTUREPATH,"%s\\Texture\\UnShadowWideTexture\\%s",m_SceneManagerPath,strZoneName);
|
||
}
|
||
}
|
||
m_WeatherManager.Load();
|
||
///////
|
||
char strTableName[256] = {0,};
|
||
char strBuffer[256] = {0,};
|
||
char *strPtr = NULL;
|
||
strcpy(strTableName,WEATHERPATH);
|
||
strPtr = strrchr(strTableName,'.');
|
||
strPtr++;
|
||
(*strPtr) = 't';
|
||
strPtr++;
|
||
(*strPtr) = 'a';
|
||
strPtr++;
|
||
(*strPtr) = 'b';
|
||
strPtr++;
|
||
(*strPtr) = 'l';
|
||
strPtr++;
|
||
(*strPtr) = 'e';
|
||
strPtr++;
|
||
(*strPtr) = 0;
|
||
FILE *fp = fopen(strTableName,"rt");
|
||
if(fp)
|
||
{
|
||
|
||
int *iPtr;
|
||
int iPtrNum;
|
||
char *str;
|
||
fgets(strBuffer,256,fp);
|
||
iPtrNum = atoi(strBuffer);
|
||
iPtr = new int[iPtrNum];
|
||
memset(strBuffer,0,sizeof(char) * 256);
|
||
fgets(strBuffer,256,fp);
|
||
int iNum;
|
||
|
||
for(iNum = 0; iNum < iPtrNum; iNum++)
|
||
{
|
||
if(iNum == 0)
|
||
str = strtok(strBuffer," \n");
|
||
else
|
||
str = strtok(NULL," \n");
|
||
iPtr[iNum] = atoi(str);
|
||
}
|
||
|
||
fclose(fp);
|
||
|
||
m_WeatherManager.LoadSubTable(iPtr,iPtrNum);
|
||
delete[] iPtr;
|
||
|
||
|
||
}
|
||
//////
|
||
CTexture::SetPath(TERRAINTEXTUREPATH);
|
||
/*
|
||
m_TerrainTexture[0].Load("hig0.dds");
|
||
m_TerrainTexture[1].Load("hig1.dds");
|
||
m_TerrainTexture[2].Load("hig2.dds");
|
||
m_TerrainTexture[3].Load("hig3.dds");
|
||
|
||
m_TerrainTexture[4].Load("med0.dds");
|
||
m_TerrainTexture[5].Load("med1.dds");
|
||
m_TerrainTexture[6].Load("med2.dds");
|
||
m_TerrainTexture[7].Load("med3.dds");
|
||
|
||
m_TerrainTexture[8].Load("low0.dds");
|
||
m_TerrainTexture[9].Load("low1.dds");
|
||
m_TerrainTexture[10].Load("low2.dds");
|
||
m_TerrainTexture[11].Load("low3.dds");
|
||
*/
|
||
CSectorScene::m_DetailTexture.Load("detail.dds");
|
||
|
||
if(CRenderOption::m_GrassRendering)
|
||
{
|
||
if(CGrassScene::m_NormalTexture==NULL)
|
||
{
|
||
CTexture::SetPath(NATURETEXTUREPATH);
|
||
CGrassScene::m_NormalTexture=new CTexture();
|
||
CGrassScene::m_NormalTexture->Load("grass.dds");
|
||
}
|
||
}
|
||
|
||
if(CRenderOption::m_RangeGrassRender)
|
||
{
|
||
CTexture::SetPath(NATURETEXTUREPATH);
|
||
|
||
CSectorScene::m_LODGrassTexture.Load("LODGrass.dds");
|
||
|
||
CSectorScene::m_GrassRangeTexture=new CTexture();
|
||
CSectorScene::m_GrassRangeTexture->Load("GrassRange.dds");
|
||
}
|
||
|
||
CTexture::SetPath(NATURETEXTUREPATH);
|
||
CSkyScene::m_CloudTexture.Load("Clouds.dds");
|
||
|
||
// Rain <20><><EFBFBD><EFBFBD> <20>߰<EFBFBD>
|
||
CSkyScene::m_LightLayerTexture[0].Load("lightning.dds");
|
||
CSkyScene::m_LightLayerTexture[1].Load("lightning1.dds");
|
||
CSkyScene::m_LightLayerTexture[2].Load("lightning2.dds");
|
||
|
||
if(CTreeScene::m_NormalTreeMesh[0]==NULL)
|
||
{
|
||
CTexture::SetPath(OBJECTTEXTUREPATH);
|
||
CSceneManager::m_MeshObjectContainer.SetPath(TREEOBJECTPATH);
|
||
|
||
char strName[256];
|
||
for(int i=0;i<MAX_TREEKIND;i++)
|
||
{
|
||
sprintf(strName,"NormalTree%d.R3S",i+1);
|
||
CTreeScene::m_NormalTreeMesh[i]=CSceneManager::m_MeshObjectContainer.GetMeshObject(strName);
|
||
if(CRenderOption::m_TreeAnimation)
|
||
CTreeScene::m_NormalTreeMesh[i]->ConvertTree();
|
||
else
|
||
CTreeScene::m_NormalTreeMesh[i]->ConvertNormal();
|
||
if(i+1<10)
|
||
sprintf(strName,"tree0%d_lod_fr.R3S",i+1);
|
||
else
|
||
sprintf(strName,"tree%d_lod_fr.R3S",i+1);
|
||
|
||
CTreeScene::m_NormalTreeMeshLOD[i]=CSceneManager::m_MeshObjectContainer.GetMeshObject(strName);
|
||
if(CRenderOption::m_TreeAnimation)
|
||
CTreeScene::m_NormalTreeMeshLOD[i]->ConvertTree();
|
||
else
|
||
CTreeScene::m_NormalTreeMeshLOD[i]->ConvertNormal();
|
||
}
|
||
}
|
||
|
||
/*
|
||
CTreeScene::m_NormalTreeLeaves[0]=CSceneManager::m_MeshObjectContainer.GetMeshObject("leaves.R3S");
|
||
CTreeScene::m_NormalTreeLeaves[0]->ConvertTree();
|
||
CTreeScene::m_NormalTreeTrunk[0]=CSceneManager::m_MeshObjectContainer.GetMeshObject("trunk.R3S");
|
||
CTreeScene::m_NormalTreeTrunk[0]->ConvertTree();
|
||
*/
|
||
|
||
char strWaterTextureName[256];
|
||
|
||
CTexture::SetPath(NATURETEXTUREPATH);
|
||
|
||
for(int i=0;i<MAX_WATERTEXTURE;i++)
|
||
{
|
||
sprintf(strWaterTextureName,"water%4d.dds",i);
|
||
int strLens=strlen(strWaterTextureName);
|
||
for(int cStr=0;cStr<strLens;cStr++)
|
||
{
|
||
if(strWaterTextureName[cStr]==' ')
|
||
strWaterTextureName[cStr]='0';
|
||
}
|
||
CWaterScene::m_WaterTexture[i].Load(strWaterTextureName);
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
void CSceneManager::BaseGraphicsDataUnload()
|
||
{
|
||
CSectorScene::m_DetailTexture.Unload();
|
||
|
||
if(CRenderOption::m_GrassRendering)
|
||
{
|
||
delete CGrassScene::m_NormalTexture;
|
||
CGrassScene::m_NormalTexture=NULL;
|
||
}
|
||
if(CTreeScene::m_NormalTreeMesh[0]!=NULL)
|
||
{
|
||
char strName[256];
|
||
for(int i=0;i<MAX_TREEKIND;i++)
|
||
{
|
||
sprintf(strName,"NormalTree%d.R3S",i+1);
|
||
m_MeshObjectContainer.DeleteMeshObject(strName);
|
||
CTreeScene::m_NormalTreeMesh[i]=NULL;
|
||
|
||
if(i+1<10)
|
||
sprintf(strName,"tree0%d_lod_fr.R3S",i+1);
|
||
else
|
||
sprintf(strName,"tree%d_lod_fr.R3S",i+1);
|
||
|
||
m_MeshObjectContainer.DeleteMeshObject(strName);
|
||
|
||
CTreeScene::m_NormalTreeMeshLOD[i]=NULL;
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
void CSceneManager::SetSceneManagerPath(char *strSceneManagerPath)
|
||
{
|
||
strcpy(m_SceneManagerPath,strSceneManagerPath);
|
||
sprintf(ROOTPATH,"%s\\",strSceneManagerPath);
|
||
sprintf(CHARACTERDATAPATH,"%s\\Character\\Data\\",strSceneManagerPath);//char CHARACTERDATAPATH[256]="c:\\MP-Project\\Character\\Data\\";
|
||
sprintf(CHARACTERTEXTUREDATAPATH,"%s\\Character\\Data\\tex\\",strSceneManagerPath);//char CHARACTERTEXTUREDATAPATH[256]="c:\\MP-Project\\Character\\Data\\tex\\";
|
||
sprintf(CHARACTERMESHTEX,"%s\\Character\\Data\\meshtex.htable",strSceneManagerPath);//char CHARACTERMESHTEX[256]="c:\\MP-Project\\Character\\Data\\meshtex.htable";
|
||
sprintf(CHARACTERANIPACK,"%s\\Character\\Data\\ani\\APack.ntable",strSceneManagerPath);//char CHARACTERANIPACK[256]="c:\\MP-Project\\Character\\Data\\ani\\APack.ntable";
|
||
sprintf(CHARACTERLODMESH,"%s\\Character\\Data\\mesh\\LODMesh.ntable",strSceneManagerPath);//char CHARACTERLODMESH[256]="c:\\MP-Project\\Character\\Data\\mesh\\LODMesh.ntable";
|
||
sprintf(CHARACTERTEXPIECE,"%s\\Character\\Data\\tex\\Texpiece.ntable",strSceneManagerPath);//char CHARACTERTEXPIECE[256]="c:\\MP-Project\\Character\\Data\\tex\\Texpiece.ntable";
|
||
sprintf(CHARACTERATTACHMENTMESH,"%s\\Character\\Data\\Amesh\\amesh.ntable",strSceneManagerPath);//char CHARACTERATTACHMENTMESH[256]="c:\\MP-Project\\Character\\Data\\Amesh\\amesh.ntable";
|
||
sprintf(CHARACTERTEXTURE,"%s\\Character\\Data\\Texture\\texture.ntable",strSceneManagerPath);//char CHARACTERTEXTURE[256]="c:\\MP-Project\\Character\\Data\\Texture\\texture.ntable";
|
||
|
||
sprintf(HOUSEOBJECTPATH,"%s\\Objects\\House\\",strSceneManagerPath);//char HOUSEOBJECTPATH[256]="c:\\MP-Project\\Objects\\House\\";
|
||
sprintf(LIGHTOBJECTPATH,"%s\\Objects\\Object\\",strSceneManagerPath);//char LIGHTOBJECTPATH[256]="c:\\MP-Project\\Objects\\Object\\";
|
||
sprintf(TREEOBJECTPATH,"%s\\Objects\\NatureObject\\",strSceneManagerPath);//char TREEOBJECTPATH[256]="c:\\MP-Project\\Objects\\NatureObject\\";
|
||
sprintf(OBJECTPATH,"%s\\Objects\\Object\\",strSceneManagerPath);//char OBJECTPATH[256]="c:\\MP-Project\\Objects\\Object\\";
|
||
sprintf(INSTANCEOBJECTPATH,"%s\\Objects\\Instance\\",strSceneManagerPath);//ect\\Objects\Instance\\;
|
||
|
||
if(CRenderOption::m_TextureMethod==1)
|
||
{
|
||
sprintf(CHARACTERTEXTURE,"%s\\Character\\Data\\Texture\\texture.ntable",strSceneManagerPath);//char CHARACTERTEXTURE[256]="c:\\MP-Project\\Character\\Data\\Texture\\texture.ntable";
|
||
sprintf(TERRAINTEXTUREPATH,"%s\\Texture\\Terrain",strSceneManagerPath);//char TERRAINTEXTUREPATH[256]="c:\\MP-project\\Texture\\Terrain";
|
||
sprintf(OBJECTTEXTUREPATH,"%s\\Texture\\Object",strSceneManagerPath);//char OBJECTTEXTUREPATH[256]="c:\\MP-Project\\Texture\\Object";
|
||
sprintf(NATURETEXTUREPATH,"%s\\Texture\\NatureObject",strSceneManagerPath);//char NATURETEXTUREPATH[256]="c:\\MP-project\\Texture\\NatureObject";
|
||
sprintf(WIDETEXTUREPATH,"%s\\Texture\\WideTexture",strSceneManagerPath);//char WIDETEXTUREPATH[256]="C:\\MP-Project\\Texture\\WideTexture";
|
||
sprintf(INTERFACETEXTUREPATH,"%s\\Texture\\Interface",strSceneManagerPath);//char INTERFACETEXTUREPATH[256]="c:\\MP-Project\\Texture\\Interface";
|
||
sprintf(FXTEXTUREPATH,"%s\\Texture\\FX",strSceneManagerPath);//char FXTEXTUREPATH[256]="c:\\MP-Project\\Texture\\FX";
|
||
sprintf(LIGHTMAPTEXTUREPATH,"%s\\Texture\\Lightmap",strSceneManagerPath);//char LIGHTMAPTEXTUREPATH[256]="c:\\MP-Project\\Texture\\Lightmap";
|
||
sprintf( EFFECTTEXTUREPATH, "%s\\Texture\\Effect\\",strSceneManagerPath );
|
||
}
|
||
else
|
||
{
|
||
sprintf(CHARACTERTEXTURE,"%s\\Character\\Data\\LowTexture\\texture.ntable",strSceneManagerPath);//char CHARACTERTEXTURE[256]="c:\\MP-Project\\Character\\Data\\Texture\\texture.ntable";
|
||
sprintf(TERRAINTEXTUREPATH,"%s\\LowTexture\\Terrain",strSceneManagerPath);//char TERRAINTEXTUREPATH[256]="c:\\MP-project\\Texture\\Terrain";
|
||
sprintf(OBJECTTEXTUREPATH,"%s\\LowTexture\\Object",strSceneManagerPath);//char OBJECTTEXTUREPATH[256]="c:\\MP-Project\\Texture\\Object";
|
||
sprintf(NATURETEXTUREPATH,"%s\\LowTexture\\NatureObject",strSceneManagerPath);//char NATURETEXTUREPATH[256]="c:\\MP-project\\Texture\\NatureObject";
|
||
sprintf(WIDETEXTUREPATH,"%s\\LowTexture\\WideTexture",strSceneManagerPath);//char WIDETEXTUREPATH[256]="C:\\MP-Project\\Texture\\WideTexture";
|
||
sprintf(INTERFACETEXTUREPATH,"%s\\LowTexture\\Interface",strSceneManagerPath);//char INTERFACETEXTUREPATH[256]="c:\\MP-Project\\Texture\\Interface";
|
||
sprintf(FXTEXTUREPATH,"%s\\LowTexture\\FX",strSceneManagerPath);//char FXTEXTUREPATH[256]="c:\\MP-Project\\Texture\\FX";
|
||
sprintf(LIGHTMAPTEXTUREPATH,"%s\\LowTexture\\Lightmap",strSceneManagerPath);//char LIGHTMAPTEXTUREPATH[256]="c:\\MP-Project\\Texture\\Lightmap";
|
||
sprintf( EFFECTTEXTUREPATH, "%s\\LowTexture\\Effect\\",strSceneManagerPath );
|
||
}
|
||
sprintf(TERRAINVERTEXSHADEROATH,"%s\\VertexShader\\LayerFog\\LayerFogTerrain.vsh",strSceneManagerPath);//char TERRAINVERTEXSHADEROATH[256]="c:\\MP-Project\\VertexShader\\LayerFog\\LayerFogTerrain.vsh";
|
||
sprintf(WEATHERPATH,"%s\\WeatherColorTable.dat",strSceneManagerPath);//char WEATHERPATH[256]="c:\\MP-Project\\WeatherColorTable.dat";
|
||
sprintf(OCTREEPATH,"%s\\Octree",strSceneManagerPath);//char OCTREEPATH[256]="c:\\MP-Project\\Octree";
|
||
sprintf(SOUNDFILEPATH,"%s\\Sound\\",strSceneManagerPath);//char SOUNDFILEPATH[256]="c:\\MP-Project\\Sound\\";
|
||
|
||
sprintf( EFFECTPATH, "%s\\Effect\\", strSceneManagerPath );
|
||
sprintf( EFFECTSOUNDSPATH,"%s\\Sound\\Effect\\Ssnd\\",strSceneManagerPath);
|
||
sprintf( EFFECTSOUNDMPATH,"%s\\Sound\\Effect\\Msnd\\",strSceneManagerPath);
|
||
|
||
// effect texture path
|
||
|
||
sprintf( EFFECTSCRIPTPATH,"%s\\Effect\\Esf\\",strSceneManagerPath);
|
||
|
||
//mesh morph
|
||
sprintf( OBJECTGEMPATH, "%s\\Objects\\Gem\\",strSceneManagerPath );
|
||
|
||
}
|
||
|
||
void CSceneManager::CharacterFirstAccelate(CZ3DGeneralChrModel *pChrmodel, bool bFirstAccelate)
|
||
{
|
||
m_CharacterManager.CharacterFirstAccelate(pChrmodel,bFirstAccelate);
|
||
}
|
||
|
||
CZ3DGeneralChrModel* CSceneManager::PickingCharacter(int MouseX, int MouseY)
|
||
{
|
||
PickMakeRay(MouseX,MouseY,BaseGraphicsLayer::m_lScreenSx,BaseGraphicsLayer::m_lScreenSy);
|
||
|
||
vector3 vecChrPos;
|
||
|
||
|
||
float fRad=50.0f;
|
||
float fNearestInterval=100.0f;
|
||
|
||
CZ3DGeneralChrModel *pResult=NULL;
|
||
|
||
vector3 vecMousePos;
|
||
vecMousePos.x=MouseX;
|
||
vecMousePos.y=MouseY;
|
||
vecMousePos.z=0.0f;
|
||
|
||
vector3 vecLens;
|
||
|
||
vector3 vecViewPos=*CSceneManager::GetCamera()->GetPosition();
|
||
|
||
for(int cChr=0;cChr<m_CharacterManager.m_CharacterList.num;cChr++)
|
||
{
|
||
m_CharacterManager.m_CharacterList[cChr].m_pChrmodel->GetPosition(vecChrPos);
|
||
vecChrPos.y+=100.0f;
|
||
|
||
vector3 vecResult;
|
||
float fW;
|
||
if(BaseGraphicsLayer::TransformVector(vecChrPos,vecResult,fW))
|
||
{
|
||
if(vecResult.z<0.0f || vecResult.z>1.0f)
|
||
continue;
|
||
|
||
vecLens=vecViewPos-vecChrPos;
|
||
|
||
float fInterCamera=vecLens.GetLens();
|
||
|
||
float fZRate=-(fInterCamera/10000.0f)+1;
|
||
|
||
vecResult.z=0.0f;
|
||
|
||
vecLens=vecMousePos-vecResult;
|
||
|
||
float fTemp=vecLens.GetLens();
|
||
|
||
if(fTemp <= fRad*fZRate)
|
||
{
|
||
pResult=m_CharacterManager.m_CharacterList[cChr].m_pChrmodel;
|
||
}
|
||
|
||
/*
|
||
float fTransRad=fRad/vecResult.z;
|
||
|
||
float fTemp=vecResult.z;
|
||
vecResult.z=0.0f;
|
||
vecLens=vecMousePos-vecResult;
|
||
|
||
if(vecLens.GetLens() <= fTransRad)
|
||
{
|
||
pResult=m_CharacterManager.m_CharacterList[cChr].m_pChrmodel;
|
||
}
|
||
*/
|
||
/*
|
||
vecResult.z=0.0f;
|
||
vecLens=vecMousePos-vecResult;
|
||
if(vecLens.GetLens()<=fNearestInterval)
|
||
{
|
||
pResult=m_CharacterManager.m_CharacterList[cChr].m_pChrmodel;
|
||
fNearestInterval=vecLens.GetLens();
|
||
}
|
||
*/
|
||
}
|
||
/*
|
||
vecChrPos.y+=150.0f;
|
||
vector3 vecInter=m_vecPickRayStart-vecChrPos;
|
||
float fC=(vecInter*vecInter)-fRad;
|
||
float fB=m_vecPickRayDir*(m_vecPickRayStart-vecChrPos);
|
||
|
||
if(fB*fB-fC>=0.0f)
|
||
{
|
||
if(vecInter.GetLens()<=fNearestInterval)
|
||
{
|
||
pResult=m_CharacterManager.m_CharacterList[cChr].m_pChrmodel;
|
||
|
||
fNearestInterval=vecInter.GetLens();
|
||
}
|
||
}
|
||
*/
|
||
}
|
||
return pResult;
|
||
/*
|
||
|
||
|
||
|
||
vector3 vecInter=m_vecPickRayStart-vecObjectPos;
|
||
|
||
float fC=(vecInter*vecInter)-fRad;
|
||
float fB=m_vecPickRayDir*(m_vecPickRayStart-vecObjectPos);
|
||
|
||
vecObjectPos=m_vecPickRayStart-vecObjectPos;
|
||
|
||
if(fB*fB-fC>=0.0f)
|
||
{
|
||
if(vecObjectPos.GetLens() <= fNearestInterval)
|
||
{
|
||
if(PickMode==2)
|
||
{
|
||
m_pBspScene->m_HouseObject->m_pBspObject->m_SelectLight=cLight;
|
||
fNearestInterval=vecObjectPos.GetLens();
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
|
||
}
|
||
|
||
void CSceneManager::CharacterCollisionAble(CZ3DGeneralChrModel *pChrmodel, bool bCollisionDetectionAble)
|
||
{
|
||
m_CharacterManager.CharacterCollisionAble(pChrmodel,bCollisionDetectionAble);
|
||
}
|
||
|
||
void CSceneManager::CharacterGravityAble(CZ3DGeneralChrModel *pChrmodel, bool bGravityAble)
|
||
{
|
||
m_CharacterManager.CharacterGravityAble(pChrmodel,bGravityAble);
|
||
}
|
||
|
||
void CSceneManager::ResetTerrain()
|
||
{
|
||
|
||
}
|
||
|
||
void CSceneManager::SetMapSize(vector3 vecMinSize, vector3 vecMaxSize)
|
||
{
|
||
m_CollisionDetection.m_vecMinMove=vecMinSize;
|
||
m_CollisionDetection.m_vecMaxMove=vecMaxSize;
|
||
}
|
||
|
||
void CSceneManager::CharacterCollisionDetectType(CZ3DGeneralChrModel *pChrmodel, int nType)
|
||
{
|
||
m_CharacterManager.CharacterCollisionDetectType(pChrmodel,nType);
|
||
}
|
||
|
||
CCharacterLightShadowManager::CCharacterDataNode CSceneManager::GetCharacterDataNode(CZ3DGeneralChrModel *pChrmodel)
|
||
{
|
||
return m_CharacterManager.GetCharacterDataNode(pChrmodel);
|
||
}
|
||
|
||
void CSceneManager::SetCharacterDataNode(CCharacterLightShadowManager::CCharacterDataNode SetNode)
|
||
{
|
||
m_CharacterManager.SetCharacterDataNode(SetNode);
|
||
}
|
||
void CSceneManager::PickSectorEffect(int b) { // 03.03.04 <20>߰<EFBFBD>
|
||
static int iPickSector = 0; // Effect Sectormap select
|
||
|
||
if(iPickSector < 0) // b<><62> 0 <20≯<EFBFBD> <20>ε<EFBFBD><CEB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 1<≯<EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
iPickSector = 0;
|
||
|
||
m_PickEffect = m_MapStorage.FindEffectMap(iPickSector);
|
||
if(!b)
|
||
iPickSector++;
|
||
else
|
||
iPickSector--;
|
||
|
||
|
||
}
|
||
void CSceneManager::PickEffect2(int b) { // 03.03.04 <20>߰<EFBFBD>
|
||
static int iPick = 0; // m_PickEffect <20><><EFBFBD><EFBFBD> effect <20><><EFBFBD><EFBFBD> <20><>ȸ<EFBFBD>Ѵ<EFBFBD>.
|
||
// b<><62> 0 <20≯<EFBFBD> <20>ε<EFBFBD><CEB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 1<≯<EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
if(iPick >= m_PickEffect->m_vecEffectPos.num)
|
||
iPick = 0;
|
||
|
||
else if(iPick < 0)
|
||
iPick = 0;
|
||
|
||
m_PickEffect->pick_index = iPick;
|
||
|
||
if(!b)
|
||
iPick++;
|
||
else
|
||
iPick--;
|
||
|
||
}
|
||
void CSceneManager::RenderInCubemap()
|
||
{
|
||
if(CRenderOption::m_WaterBumpEnvRendering)
|
||
{
|
||
D3DXMATRIX matOldProj,matOldView,matOldWorld;
|
||
|
||
D3DXMATRIX matProj;
|
||
D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI * 0.5f, 1.0f, 50.0f,620000.0f);
|
||
|
||
D3DVIEWPORT8 Viewport;
|
||
D3DVIEWPORT8 CubeViewport;
|
||
|
||
CubeViewport.X = 0;
|
||
CubeViewport.Y = 0;
|
||
CubeViewport.Width = 256;
|
||
CubeViewport.Height = 256;
|
||
CubeViewport.MinZ = 0.0f;
|
||
CubeViewport.MaxZ = 1.0f;
|
||
m_pd3dDevice->GetViewport(&Viewport);
|
||
|
||
m_pd3dDevice->GetTransform(D3DTS_VIEW,&matOldView);
|
||
m_pd3dDevice->GetTransform(D3DTS_PROJECTION,&matOldProj);
|
||
m_pd3dDevice->GetTransform(D3DTS_WORLD,&matOldWorld);
|
||
|
||
vector3 vecCameraPos;
|
||
D3DXMATRIX matInvOldView;
|
||
D3DXMatrixInverse(&matInvOldView,NULL,&matOldView);
|
||
vecCameraPos.x = matInvOldView._41;
|
||
vecCameraPos.y = matInvOldView._42;
|
||
vecCameraPos.z = matInvOldView._43;
|
||
|
||
//// Get ViewDir
|
||
D3DXMATRIX matT,matResult;
|
||
D3DXVECTOR3 vecT(0.0f, 0.0f, 1.0f);
|
||
D3DXMatrixTranslation(&matT, vecT.x, vecT.y, vecT.z);
|
||
|
||
D3DXMatrixMultiply(&matResult, &matT, &matOldView);
|
||
vector3 *vecViewPos=CSceneManager::GetCamera()->GetPosition();
|
||
vector3 vecToward = CSceneManager::GetCamera()->GetViewTowardVector();
|
||
vecToward.Normalize();
|
||
|
||
////
|
||
D3DXMATRIX matViewDir( matOldView );
|
||
matViewDir._41 = 0.0f; matViewDir._42 = 0.0f; matViewDir._43 = 0.0f;
|
||
|
||
m_pRenderEnvMap->BeginCube( m_pWorldCubemap );
|
||
m_pd3dDevice->SetViewport(&CubeViewport);
|
||
for( UINT i = 0; i < 6; i++ )
|
||
{
|
||
m_pRenderEnvMap->Face( (D3DCUBEMAP_FACES) i );
|
||
|
||
// Set the view transform for this cubemap surface
|
||
D3DXMATRIX matView;
|
||
D3DXMATRIX matWorld;
|
||
D3DXMatrixIdentity(&matWorld);
|
||
vector3 vecDir;
|
||
|
||
matView = GetCubeMatrix( i ,vecDir);
|
||
|
||
//D3DXMatrixMultiply( &matView, &matViewDir, &matView );
|
||
|
||
D3DXMatrixInverse(&matView,NULL,&matView);
|
||
|
||
//vector3 *vecViewPos=CSceneManager::GetCamera()->GetPosition();
|
||
//matView._41 = vecViewPos->x;
|
||
//matView._42 = vecViewPos->y;
|
||
///matView._42 = 600.0f;
|
||
//matView._43 = vecViewPos->z;
|
||
matView._41 = vecCameraPos.x;
|
||
matView._42 = vecCameraPos.y;
|
||
matView._43 = vecCameraPos.z;
|
||
|
||
D3DXMatrixInverse(&matView,NULL,&matView);
|
||
|
||
m_pd3dDevice->Clear( 0, NULL, D3DCLEAR_ZBUFFER|D3DCLEAR_TARGET, BaseGraphicsLayer::m_ClearColor.c, 1.0f, 0 );
|
||
m_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
|
||
m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
|
||
m_pd3dDevice->SetTransform( D3DTS_WORLD,&matWorld);
|
||
|
||
if(i == 3) // Negative Y
|
||
continue;
|
||
else if(i != 2) // Positive Y always Render
|
||
{ // View Direction Check
|
||
float fDot = vecDir * vecToward;
|
||
if(fDot < 0)
|
||
continue;
|
||
|
||
}
|
||
|
||
|
||
m_WeatherManager.RenderEnv(m_pd3dDevice);
|
||
//m_WeatherManager.Render(m_pd3dDevice);
|
||
m_HeightField.RenderEnv(m_pd3dDevice);
|
||
// m_HeightField.Render(m_pd3dDevice,true);
|
||
// m_WeatherManager.SecondRender(m_pd3dDevice);
|
||
|
||
|
||
}
|
||
|
||
m_pRenderEnvMap->End();
|
||
|
||
//HRESULT hr = D3DXSaveTextureToFile("c:/testEnv.dds", D3DXIFF_DDS ,m_pWorldCubemap,NULL);
|
||
|
||
m_pd3dDevice->SetTransform( D3DTS_VIEW, &matOldView );
|
||
m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matOldProj );
|
||
m_pd3dDevice->SetTransform(D3DTS_WORLD,&matOldWorld);
|
||
m_pd3dDevice->SetViewport(&Viewport);
|
||
}
|
||
|
||
}
|
||
D3DXMATRIX CSceneManager::GetCubeMatrix(int i,vector3 &vecDir)
|
||
{
|
||
D3DXVECTOR3 vEyePt = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
|
||
D3DXVECTOR3 vLookDir;
|
||
D3DXVECTOR3 vUpDir;
|
||
|
||
switch( i )
|
||
{
|
||
case 0:
|
||
vLookDir = D3DXVECTOR3( 1.0f, 0.0f, 0.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
break;
|
||
case 1:
|
||
vLookDir = D3DXVECTOR3(-1.0f, 0.0f, 0.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
break;
|
||
case 2:
|
||
vLookDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
|
||
break;
|
||
case 3:
|
||
vLookDir = D3DXVECTOR3( 0.0f,-1.0f, 0.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
|
||
break;
|
||
case 4:
|
||
vLookDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
break;
|
||
case 5:
|
||
vLookDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
|
||
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
|
||
break;
|
||
}
|
||
vecDir.x = vLookDir.x;
|
||
vecDir.y = vLookDir.y;
|
||
vecDir.z = vLookDir.z;
|
||
|
||
D3DXMATRIX matView;
|
||
D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookDir, &vUpDir );
|
||
return matView;
|
||
|
||
}
|
||
bool CSceneManager::CheckRayCollision(const D3DXVECTOR3 &vecPos1,const D3DXVECTOR3 &vecPos2)
|
||
{
|
||
|
||
return m_HeightField.CheckRayCollision(vecPos1,vecPos2);
|
||
|
||
} |