RomkaZVO/FC1
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
main
FC1/Cry3DEngine/3dEngine.cpp
romkazvo 34d6c5d489 123
2023-08-07 19:29:24 +08:00

2638 lines
78 KiB
C++
Raw Permalink Blame History

////////////////////////////////////////////////////////////////////////////
//
// Crytek Engine Source File.
// Copyright (C), Crytek Studios, 2002.
// -------------------------------------------------------------------------
// File name: 3dengine.cpp
// Version: v1.00
// Created: 28/5/2001 by Vladimir Kajalin
// Compilers: Visual Studio.NET
// Description: Implementation of I3DEngine interface methods
// -------------------------------------------------------------------------
// History:
//
////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "3dEngine.h"
#include "visareas.h"
#include "objman.h"
#include "terrain_water.h"
#include "CryStaticModel.h"
#include "partman.h"
#include "DecalManager.h"
#include "bflyes.h"
#include "rain.h"
#include "meshidx.h"
#include "detail_grass.h"
#include "StencilShadowEdgeDetector.h" // CStencilShadowEdgeDetector
#include "StencilShadowConnectivityBuilder.h" // CStencilShadowConnectivityBuilder
#include "watervolumes.h"
#include "LMCompStructures.h"
#include "LMSerializationManager2.h"
#include "brush.h"
ISystem * Cry3DEngineBase::m_pSys=0;
IRenderer * Cry3DEngineBase::m_pRenderer=0;
ITimer * Cry3DEngineBase::m_pTimer=0;
ILog * Cry3DEngineBase::m_pLog=0;
IPhysicalWorld * Cry3DEngineBase::m_pPhysicalWorld=0;
IConsole * Cry3DEngineBase::m_pConsole=0;
I3DEngine * Cry3DEngineBase::m_p3DEngine=0;
CVars * Cry3DEngineBase::m_pCVars=0;
ICryPak * Cry3DEngineBase::m_pCryPak=0;
int Cry3DEngineBase::m_nRenderStackLevel=0;
int Cry3DEngineBase::m_dwRecursionDrawFlags[2]={0,0};
int Cry3DEngineBase::m_nRenderFrameID = 0;
bool Cry3DEngineBase::m_bProfilerEnabled = false;
int Cry3DEngineBase::m_CpuFlags=0;
double Cry3DEngineBase::m_SecondsPerCycle=0;
float Cry3DEngineBase::m_fPreloadStartTime=0;
bool Cry3DEngineBase::m_bIgnoreFakeMaterialsInCGF = false;
bool Cry3DEngineBase::m_bEditorMode = false;
ESystemConfigSpec Cry3DEngineBase::m_configSpec = CONFIG_VERYHIGH_SPEC;
ESystemConfigSpec Cry3DEngineBase::m_LightConfigSpec = CONFIG_VERYHIGH_SPEC;
#define LAST_POTENTIALLY_VISIBLE_TIME 2
//////////////////////////////////////////////////////////////////////
C3DEngine::C3DEngine(ISystem * pSystem)
{
CXFile::SetIPack(pSystem->GetIPak());
Cry3DEngineBase::m_pSys=pSystem;
Cry3DEngineBase::m_pRenderer=pSystem->GetIRenderer();
Cry3DEngineBase::m_pTimer=pSystem->GetITimer();
Cry3DEngineBase::m_pLog=pSystem->GetILog();
Cry3DEngineBase::m_pPhysicalWorld=pSystem->GetIPhysicalWorld();
Cry3DEngineBase::m_pConsole=pSystem->GetIConsole();
Cry3DEngineBase::m_p3DEngine=this;
Cry3DEngineBase::m_pCryPak=pSystem->GetIPak();
Cry3DEngineBase::m_pCVars=0;
Cry3DEngineBase::m_CpuFlags=pSystem->GetCPUFlags();
Cry3DEngineBase::m_SecondsPerCycle=pSystem->GetSecondsPerCycle();
#ifdef _DEBUG
#ifndef _XBOX
// _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); // _crtBreakAlloc
// _controlfp( _EM_INEXACT,_MCW_EM );
#endif
#endif
m_pShadowEdgeDetector=new CStencilShadowEdgeDetector();
m_pConnectivityBuilder=new CStencilShadowConnectivityBuilder();
m_pStaticConnectivityBuilder = new CStencilShadowStaticConnectivityBuilder();
m_pRenderCallbackFunc = NULL;
memset(m_SunObject, 0, sizeof(m_SunObject));
m_pBlurObj=0;
m_pBlurObj=GetRenderer()->EF_GetObject(false, -1);
m_pScreenObj=0;
m_pScreenObj=GetRenderer()->EF_GetObject(false, -1);
m_szLevelFolder[0]=0;
m_nFlags=0;
m_pRE2DQuad=0;
m_pSHFullScreenQuad = NULL;
m_pSHSky = NULL;//GetRenderer()->EF_LoadShader("InfRedGal", eSH_World, EF_SYSTEM);
m_pTerrainWaterShader = m_pSunRoadShader = 0;
m_nWaterBottomTexId=0;
m_pSHLensFlares = GetRenderer()->EF_LoadShader("CryLight", eSH_World, EF_SYSTEM);
m_vSunPosition = Vec3d(0, -10000.0f, 10000.0f);
m_pSHDefault = GetRenderer()->EF_LoadShader("Default", eSH_World, EF_SYSTEM);
m_pTerrain=0;
m_bEnabled=1;
ITexPic * pPic = GetRenderer()->EF_LoadTexture("diskette.tga",0,0,eTT_Base);
m_nStreamingIconTexID = pPic->GetTextureID();
pPic = GetRenderer()->EF_LoadTexture("black.tga",0,0,eTT_Base);
m_nBlackTexID = pPic->GetTextureID();
ITexPic * pPicSpot = GetRenderer()->EF_LoadTexture("spot_shadow.tga",0,0,eTT_Base);
m_nShadowSpotTexId = pPicSpot->GetTextureID();
// create components
m_pObjManager = 0;//new CObjManager (m_pSystem);
m_pPartManager = 0;
m_pDecalManager = 0;//new CDecalManager (m_pSystem, this);
// m_pBFManager = new CBFManager ();
m_pRainManager = new CRainManager ();
m_pVisAreaManager = 0;
m_pCVars = new CVars();
Cry3DEngineBase::m_pCVars = m_pCVars;
// create REs
m_pRESky = (CRESky*) GetRenderer()->EF_CreateRE(eDATA_Sky); m_pRESky->m_fAlpha = 1.f;
//m_pREOutSpace = (CREOutSpace * ) GetRenderer()->EF_CreateRE(eDATA_OutSpace);
m_pREDummy = (CREDummy*) GetRenderer()->EF_CreateRE(eDATA_Dummy);
m_pRETerrainParticles = (CRETerrainParticles*)GetRenderer()->EF_CreateRE(eDATA_TerrainParticles);
m_pRE2DQuad = (CRE2DQuad*) GetRenderer()->EF_CreateRE(eDATA_2DQuad);
m_pREScreenProcess = (CREScreenProcess*) GetRenderer()->EF_CreateRE(eDATA_ScreenProcess);
m_pSHScreenTexMap = GetRenderer()->EF_LoadShader("ScreenTexMap", eSH_World, EF_SYSTEM);
m_pSHScreenProcess = GetRenderer()->EF_LoadShader("ScreenProcess", eSH_World, EF_SYSTEM);
m_pSHOutSpace = GetRenderer()->EF_LoadShader("OutSpace", eSH_World, EF_SYSTEM);
m_pSHFarTreeSprites = GetRenderer()->EF_LoadShader("FarTreeSprites", eSH_World, EF_SYSTEM);
m_pSHClearStencil = GetRenderer()->EF_LoadShader("ClearStencil", eSH_World, EF_SYSTEM);
m_pSHShadowMapGen = GetRenderer()->EF_LoadShader("ShadowMapGen", eSH_World, EF_SYSTEM);
m_pSHBinocularDistortMask = GetRenderer()->EF_LoadShader("BinocularDistortMask", eSH_World, EF_SYSTEM);
m_pSHScreenDistort = GetRenderer()->EF_LoadShader("ScreenDistort", eSH_World, EF_SYSTEM);
m_pSHSniperDistortMask = GetRenderer()->EF_LoadShader("SniperDistortMask", eSH_World, EF_SYSTEM);
m_pSHRainMap = GetRenderer()->EF_LoadShader("RainMap", eSH_World, EF_SYSTEM);
m_pSHStencil = GetRenderer()->EF_LoadShader("<Stencil>", eSH_World, EF_SYSTEM);
m_pSHStencilState = GetRenderer()->EF_LoadShader("StencilState", eSH_World, EF_SYSTEM);
m_pSHStencilStateInv = GetRenderer()->EF_LoadShader("StencilStateInv", eSH_World, EF_SYSTEM);
m_pSHTerrainParticles = GetRenderer()->EF_LoadShader("TerrainParticles", eSH_World, EF_SYSTEM);
m_pPhysMaterialEnumerator=0;
m_fMaxViewDist = 1024;
m_fWorldColorRatio = 1;
m_vWorldColorConst(0.5f,0.5f,0.5f);
m_fWaterBumpAmountX = 0.08f;
m_fWaterBumpAmountY = 0.11f;
m_fWaterBorderTranspRatio = m_fWaterReflectRatio = m_fWaterTranspRatio = 1.f;
m_fSkyBoxAngle=0;
m_fSkyBoxStretching=0;
m_fSunHeightScale=0;
m_pFogTopPlane=0;
m_vWindForce(0,-8,0);
m_pMatMan = new CMatMan();
m_bShore = m_bOcean = true;
m_pREShadowMapGenerator = (CREShadowMapGen*)GetRenderer()->EF_CreateRE(eDATA_ShadowMapGen);
m_bTerrainLightMapGenError = false;
m_vUnderWaterFogColor.Set(0.2f,0.35f,0.4f);
m_fUnderWaterFogDistance = 16;
m_bOceanCaustics = true;
m_fFogFarDist = DEFAULT_ZMAX;
m_nRealLightsNum=0;
m_pSysSpec = GetConsole()->GetCVar( "sys_spec" );
m_pLightQuality = GetConsole()->GetCVar("r_Quality_BumpMapping");
}
//////////////////////////////////////////////////////////////////////
C3DEngine::~C3DEngine()
{
assert(IsHeapValid());
ShutDown();
delete m_pPartManager;
delete m_pDecalManager;
// delete m_pBFManager;
delete m_pRainManager;
delete m_pVisAreaManager;
delete m_pObjManager;
delete m_pCVars;
delete m_pMatMan; m_pMatMan=0;
SAFE_RELEASE(m_pRESky);
//m_pREOutSpace->Release();
SAFE_RELEASE(m_pREDummy);
SAFE_RELEASE(m_pRETerrainParticles);
SAFE_RELEASE(m_pRE2DQuad);
SAFE_RELEASE(m_pREShadowMapGenerator);
SAFE_RELEASE(m_pREScreenProcess);
if (m_pSHLensFlares)
m_pSHLensFlares->Release(true);
if (m_pSHDefault)
m_pSHDefault->Release(true);
if (m_pSHScreenTexMap)
m_pSHScreenTexMap->Release(true);
if (m_pSHScreenProcess)
m_pSHScreenProcess->Release(true);
if (m_pSHOutSpace)
m_pSHOutSpace->Release(true);
if (m_pSHFarTreeSprites)
m_pSHFarTreeSprites->Release(true);
if (m_pSHClearStencil)
m_pSHClearStencil->Release(true);
if (m_pSHShadowMapGen)
m_pSHShadowMapGen->Release(true);
if (m_pSHBinocularDistortMask)
m_pSHBinocularDistortMask->Release(true);
if (m_pSHScreenDistort)
m_pSHScreenDistort->Release(true);
if (m_pSHSniperDistortMask)
m_pSHSniperDistortMask->Release(true);
if (m_pSHRainMap)
m_pSHRainMap->Release(true);
if (m_pSHStencil)
m_pSHStencil->Release(true);
if (m_pSHStencilState)
m_pSHStencilState->Release(true);
if (m_pSHStencilStateInv)
m_pSHStencilStateInv->Release(true);
if (m_pSHTerrainParticles)
m_pSHTerrainParticles->Release(true);
if (m_nStreamingIconTexID)
{
GetRenderer()->RemoveTexture(m_nStreamingIconTexID);
m_nStreamingIconTexID = 0;
}
if (m_nShadowSpotTexId)
{
GetRenderer()->RemoveTexture(m_nShadowSpotTexId);
m_nShadowSpotTexId = 0;
}
delete m_pShadowEdgeDetector;
delete m_pConnectivityBuilder;
delete m_pStaticConnectivityBuilder;
GetLog()->Log ("\003----------------------------------------------------------------------");
GetLog()->Log ("\003Cry3DEngine profile statistics:");
GetLog()->Log ("\003I3DEngine::MakeObject() : %4.1f sec", CObjManager::m_dMakeObjectTime);
GetLog()->Log ("\003I3DEngine::LoadLevel() : %4.1f sec", m_dLoadLevelTime);
GetLog()->Log ("\003I3DEngine::LoadMaterial() : %4.1f sec", CObjManager::m_dCIndexedMesh__LoadMaterial);
GetLog()->Log ("\003I3DEngine::UpdateCustomLightingSpritesAndShadowMaps() : %4.1f sec", CObjManager::m_dUpdateCustomLightingSpritesAndShadowMaps);
GetLog()->Log ("\003----------------------------------------------------------------------");
}
//////////////////////////////////////////////////////////////////////
bool C3DEngine::Init()
{
ShutDown();
return (true);
}
bool C3DEngine::IsCameraAnd3DEngineInvalid(const CCamera cam, const char * szCaller)
{
const Vec3d & vCamPos = cam.GetPos();
const Vec3d & vAngles = cam.GetAngles();
const float fFov = cam.GetFov();
if (!m_pObjManager || !m_pDecalManager)
{
//GetLog()->Log("Warning: %s: Engine not initialized or level not loaded");
return (true);
}
if( m_fMaxViewDist<=0 || m_fFogFarDist<=0 ||
!_finite(vCamPos.x) || !_finite(vCamPos.y) || !_finite(vCamPos.z) ||
!_finite(vAngles.x) || !_finite(vAngles.y) || !_finite(vAngles.z) ||
IsEquivalent(vCamPos,Vec3d(0,0,0),VEC_EPSILON) || vCamPos.z < -GetTerrainSize()*4 || vCamPos.z > GetTerrainSize()*4 ||
fFov < 0.025f || fFov > gf_PI)
{
Warning(0,0,"%s: Camera undefined : Pos=(%.1f, %.1f, %.1f), Rot=(%.1f, %.1f, %.1f), Fov=%.1f, MaxViewDist=%.1f, FogFarDist=%.1f",
szCaller,
vCamPos.x, vCamPos.y, vCamPos.z,
vAngles.x, vAngles.y, vAngles.z,
fFov, m_fMaxViewDist, m_fFogFarDist);
return true;
}
return false;
}
void C3DEngine::Update()
{
m_bProfilerEnabled = GetISystem()->GetIProfileSystem()->IsProfiling();
m_configSpec = GetISystem()->GetConfigSpec();
m_LightConfigSpec = (ESystemConfigSpec)GetCurrentLightSpec();
/// if(m_pVisAreaManager)
// m_pVisAreaManager->Preceche(m_pObjManager);
}
//////////////////////////////////////////////////////////////////////
void C3DEngine::UpdateScene(bool bAddStaticLights, bool bAlwaysAddSun)
{
if(IsCameraAnd3DEngineInvalid(GetViewCamera(), "C3DEngine::Update"))
return;
Vec3d vTerrainColor = GetSystem()->GetI3DEngine()->GetWorldColor();//*GetSystem()->GetI3DEngine()->GetWorldBrightnes();
GetRenderer()->EF_SetWorldColor(vTerrainColor[0],vTerrainColor[1],vTerrainColor[2],1);
if( bAlwaysAddSun || (GetCVars()->e_sun && IsOutdoorVisible() && m_pObjManager && m_pVisAreaManager) )
{
// Add sun lsource
CDLight DynLight;
// memset(&DynLight, 0, sizeof(CDLight));
DynLight.m_Origin = GetSunPosition();//Vec3d(0, -5000.0f, 5000.0f);
DynLight.m_fRadius = 100000000;
DynLight.m_Color = GetSunColor();
DynLight.m_Color.r *= GetWorldColor().x;
DynLight.m_Color.g *= GetWorldColor().y;
DynLight.m_Color.b *= GetWorldColor().z;
DynLight.m_SpecColor= GetSunColor();
DynLight.m_SpecColor.r *= GetWorldColor().x;
DynLight.m_SpecColor.g *= GetWorldColor().y;
DynLight.m_SpecColor.b *= GetWorldColor().z;
DynLight.m_Flags |= DLF_DIRECTIONAL | DLF_SUN | DLF_THIS_AREA_ONLY | DLF_LM | DLF_CASTSHADOW_MAPS;
if(GetCVars()->e_sun_stencil)
DynLight.m_Flags |= DLF_CASTSHADOW_VOLUME;
for(int i=0; i<GetCVars()->e_sun; i++)
AddDynamicLightSource(DynLight,(IEntityRender*)-1);
}
if(bAddStaticLights)
UpdateStaticLightSources();
LightSourcesDebug();
if(m_pObjManager && m_pTerrain)
m_pTerrain->SetCBuffer(m_pObjManager->m_pCoverageBuffer);
m_bTerrainLightMapGenError = false;
}
//////////////////////////////////////////////////////////////////////
void C3DEngine::ShutDown(bool bEditorMode)
{
if(GetRenderer() != GetSystem()->GetIRenderer())
GetSystem()->Error("Renderer was deallocated before I3DEngine::ShutDown() call");
// reinit console variables
// delete m_pCVars;
// m_pCVars = new CVars(m_pSystem);
GetLog()->Log("Removing lights ...");
for(int i=0; i<m_lstDynLights.Count(); i++)
{
CDLight * pLight = &m_lstDynLights[i];
FreeLightSourceComponents(pLight);
}
DeleteAllStaticLightSources();
GetLog()->Log("Deleting visareas ...");
delete m_pVisAreaManager;
m_pVisAreaManager = 0;
GetLog()->Log("Deleting terrain ...");
// list2<struct IEntityRender*> lstTerrainObjects;
// if(m_pTerrain)
// m_pTerrain->GetObjects(lstTerrainObjects);
delete m_pTerrain;
m_pTerrain=0;
GetLog()->Log("ObjManager shutdown ...");
delete m_pObjManager;
m_pObjManager=0;
GetRenderer()->DeleteLeafBuffer(m_pFogTopPlane);
m_pFogTopPlane=0;
SAFE_RELEASE(m_pSHSky);
}
//////////////////////////////////////////////////////////////////////
void C3DEngine::ActivateLight(const char *szName,bool bActivate)
{
assert(0);
// GetBuildingManager()->ActivateLight(szName,bActivate);
}
#ifdef WIN64
#pragma warning( push ) //AMD Port
#pragma warning( disable : 4311 )
#endif
//////////////////////////////////////////////////////////////////////
void C3DEngine::SetCamera(const CCamera &cam, bool bToTheScreen)
{
// if(GetCVars()->e_hires_screenshoot)
// return;
if(IsCameraAnd3DEngineInvalid(cam, "C3DEngine::SetCamera"))
return;
GetViewCamera() = cam;
// realtime skybox processing
if(GetCVars()->e_out_space)
{
const float fNearFarDistance = 64;
if(bToTheScreen)
{
GetViewCamera().SetZMin(DEFAULT_ZMIN);
GetViewCamera().SetZMax(fNearFarDistance*1.5f);
}
else
{
GetViewCamera().SetZMin(fNearFarDistance*0.75f);
GetViewCamera().SetZMax(DEFAULT_ZMAX);
m_fMaxViewDist = DEFAULT_ZMAX;
}
}
else if(GetViewCamera().GetZMax()>m_fMaxViewDist)
GetViewCamera().SetZMax(m_fMaxViewDist);
/*
Vec3d vPosTest(106,120,0);
vPosTest.z = GetWaterLevel(&vPosTest);
GetRenderer()->Draw3dBBox(vPosTest-Vec3d(0.05f,0.05f,0.05f),vPosTest+Vec3d(0.05f,0.05f,0.05f));
*/
// under water camera effects
// float fUnderWater = GetWaterLevel(&GetViewCamera().GetPos())-GetViewCamera().GetPos().z;
// int nRecursionLevel = (int)GetRenderer()->EF_Query(EFQ_RecurseLevel);
// float fZMin = GetViewCamera().GetZMin();
//if(fUnderWater>(-fZMin) && nRecursionLevel==0)
{
// modify camera pos
/* if(fUnderWater>-0.04f) // if very close to the water - jump 5sm down
GetViewCamera().SetPos(GetViewCamera().GetPos()-Vec3d(0,0,0.08f));
// set z near
if(fabs(fUnderWater)<fZMin)
GetViewCamera().SetZMin(fZMin*0.2f);
*/
// set animated fov
/*if(fUnderWater>0)
{
if(fUnderWater>1)
fUnderWater=1;
float k = 1.f+0.1f*(float)cry_sinf(2.f*GetTimer()->GetCurrTime())*fUnderWater;
// CCamera cam = GetViewCamera();
GetViewCamera().SetFov(gf_PI_DIV_2/(k*0.6f+0.4f));
GetViewCamera().SetProjRatio((600.f/800.f)*k);
}*/
}
//GetViewCamera().Init(GetRenderer()->GetWidth(), GetRenderer()->GetHeight(),
//GetViewCamera().GetFov(), m_fMaxViewDist, GetViewCamera().GetProjRatio(), GetViewCamera().GetZMin());
GetViewCamera().Init(GetRenderer()->GetWidth(), GetRenderer()->GetHeight(),
GetViewCamera().GetFov(), m_fMaxViewDist, 0, GetViewCamera().GetZMin());
GetViewCamera().Update();
GetRenderer()->SetCamera(GetViewCamera());
if (m_pTerrain && bToTheScreen)
{
m_pObjManager->m_fZoomFactor = 0.05f + 0.95f*(RAD2DEG(GetViewCamera().GetFov())/90.f);
m_pTerrain->m_fLodLFactor = m_pObjManager->m_fZoomFactor*m_pObjManager->m_fZoomFactor;
}
}
#ifdef WIN64
#pragma warning( pop ) //AMD Port
#endif
IStatObj * C3DEngine::MakeObject(const char * szFileName, const char * szGeomName,
EVertsSharing eVertsSharing,
bool bLoadAdditinalInfo, bool bKeepInLocalSpace)
{
if(!szFileName || !szFileName[0])
{
Warning( 0,0,"I3DEngine::MakeObject: filename is not specified");
return 0;
}
if(!m_pObjManager)
m_pObjManager = new CObjManager (this);
return m_pObjManager->MakeObject(szFileName, szGeomName, eVertsSharing, bLoadAdditinalInfo, bKeepInLocalSpace);
}
bool C3DEngine::ReleaseObject(IStatObj * pObject)
{
if(!m_pObjManager || !pObject)
return 0;
if(!m_pObjManager->ReleaseObject((CStatObj*)pObject))
{
GetLog()->Log("Warning: I3DEngine::ReleaseObject: Attempt to release invalid IStatObj pointer");
return false;
}
return true;
}
IStatObj* C3DEngine::MakeObject()
{
return new CStatObj();
}
void C3DEngine::RegisterEntity( IEntityRender* pEntityRS )
{
FUNCTION_PROFILER_FAST( GetSystem(),PROFILE_3DENGINE,m_bProfilerEnabled );
// if(strstr(pEntityRS->GetEntityClassName(),"Light"))
// int y=0;
#ifdef _DEBUG // crash test basically
const char * szClass = pEntityRS->GetEntityClassName();
const char * szName = pEntityRS->GetName();
if(!szName[0] && !szClass[0])
Warning(0,0,"C3DEngine::RegisterEntity: Entity undefined"); // do not register undefined objects
if(!_finite(pEntityRS->GetPos().x) || !_finite(pEntityRS->GetPos().y) || !_finite(pEntityRS->GetPos().z))
{
Warning(0,0,"Warning: C3DEngine::RegisterEntity: Entity position undefined: %s", szName);
return;
}
#endif
if(!GetCVars()->e_register_in_sectors)
return; // speed test
/*
ICryCharInstance * cmodel = pEntityRS->GetEntityCharacter(0);
if(cmodel && (cmodel->GetFlags() & CS_FLAG_DRAW_NEAR))
{
if(cmodel->GetFlags() & CS_FLAG_DRAW_MODEL)
int t=0;
}
*/
if(!pEntityRS->GetEntityRS())
return;
pEntityRS->GetRenderBBox(pEntityRS->m_vWSBoxMin, pEntityRS->m_vWSBoxMax);
assert(_finite(pEntityRS->m_vWSBoxMin.x) && _finite(pEntityRS->m_vWSBoxMin.y) && _finite(pEntityRS->m_vWSBoxMin.z));
assert(_finite(pEntityRS->m_vWSBoxMax.x) && _finite(pEntityRS->m_vWSBoxMax.y) && _finite(pEntityRS->m_vWSBoxMax.z));
pEntityRS->m_fWSRadius = GetDistance(pEntityRS->m_vWSBoxMin, pEntityRS->m_vWSBoxMax)*0.5f;
// if(!pEntityRS->GetEntityRS()->pOcclState)
// pEntityRS->GetEntityRS()->pOcclState = new OcclusionTestClient;
// if(pEntityRS->GetRndFlags()&ERF_SELECTED)
// int iww=0;
if(!(pEntityRS->GetRndFlags()&ERF_OUTDOORONLY) && // do not find vis area if this flag is not set
m_pVisAreaManager && m_pVisAreaManager->SetEntityArea(pEntityRS))
return;
assert(m_pTerrain == m_pObjManager->m_pTerrain);
if(m_pObjManager)
m_pObjManager->RegisterEntity(pEntityRS);
}
bool C3DEngine::UnRegisterEntity( IEntityRender* pEntityRS )
{
FUNCTION_PROFILER_FAST( GetSystem(),PROFILE_3DENGINE,m_bProfilerEnabled );
if(!GetCVars()->e_register_in_sectors)
return true; // speed test
#ifdef _DEBUG // crash test basically
const char * szClass = pEntityRS->GetEntityClassName();
const char * szName = pEntityRS->GetName();
if(!szName[0] && !szClass[0])
Warning(0,0,"C3DEngine::RegisterEntity: Entity undefined"); // do not register undefined objects
#endif
bool bFound = false;
if(m_pObjManager && m_pVisAreaManager)
bFound |= m_pVisAreaManager->UnRegisterEntity(pEntityRS);
if(m_pTerrain)
{
assert(m_pTerrain == m_pObjManager->m_pTerrain);
if(m_pObjManager && m_pTerrain == m_pObjManager->m_pTerrain)
bFound |= m_pObjManager->UnRegisterEntity(pEntityRS);
}
/*
#ifdef _DEBUG
if(pEntityRS->m_pSector || pEntityRS->m_pVisArea)
{
const char * szName = pEntityRS->GetName();
GetLog()->Log("Error: C3DEngine::UnRegisterEntity: Entity %s(ptr=%d) was not fully unregistered", szName, (int)pEntityRS);
assert(0);
}
if((m_pTerrain && m_pTerrain->UnRegisterInAllSectors(pEntityRS)) ||
(m_pVisAreaManager && m_pVisAreaManager->UnRegisterInAllSectors(pEntityRS)))
{
const char * szName = pEntityRS->GetName();
GetLog()->Log("Error: C3DEngine::UnRegisterEntity: Entity %s(ptr=%d) was found after unregistration", szName, (int)pEntityRS);
assert(0);
}
#endif
*/
return bFound;
}
bool C3DEngine::UnRegisterInAllSectors(IEntityRender * pEntityRS)
{
if(m_pObjManager && m_pVisAreaManager)
m_pVisAreaManager->UnRegisterEntity(pEntityRS);
if(m_pTerrain)
return m_pTerrain->UnRegisterInAllSectors(pEntityRS);
return 0;
}
void C3DEngine::SpawnParticles( const ParticleParams & SpawnParticleParams )
{
if(m_pPartManager)
m_pPartManager->Spawn( SpawnParticleParams,m_fMaxViewDist, m_pObjManager);
}
void C3DEngine::CreateDecal( const CryEngineDecalInfo& DecalInfo )
{
if(!GetCVars()->e_decals)
return;
// if(DecalInfo.nTid != 4276)
// return;
if(GetCVars()->e_decals == 2)
GetLog()->Log("Debug: C3DEngine::CreateDecal: Pos=(%.1f,%.1f,%.1f) Size=%.2f ObjName=%s nPartID=%d", DecalInfo.vPos.x, DecalInfo.vPos.y, DecalInfo.vPos.z, DecalInfo.fSize, DecalInfo.pDecalOwner ? DecalInfo.pDecalOwner->GetName() : "NULL", DecalInfo.nPartID);
if(DecalInfo.pDecalOwner)
if(DecalInfo.pDecalOwner->GetEntityCharacter(0) || DecalInfo.pDecalOwner->GetEntityCharacter(1))
{
ICryCharInstance* pChar = DecalInfo.pDecalOwner->GetEntityCharacter(0);
if(pChar)
{
CryEngineDecalInfo DecalLCS = DecalInfo;
Matrix44 matCharacter;
matCharacter.SetIdentity();
Vec3d vAngles = DecalInfo.pDecalOwner->GetAngles();
matCharacter=matCharacter*Matrix33::CreateRotationX( DEG2RAD(-vAngles.x) );
matCharacter=matCharacter*Matrix33::CreateRotationY( DEG2RAD(+vAngles.y) ); //IMPORTANT: radian-angle must be negated
matCharacter=matCharacter*Matrix33::CreateRotationZ( DEG2RAD(-vAngles.z) );
matCharacter.SetTranslationOLD (DecalInfo.pDecalOwner->GetPos());
Matrix44 matInvCharacter = GetInverted44(matCharacter);
DecalLCS.vPos = matInvCharacter.TransformPointOLD(DecalInfo.vPos);
DecalLCS.vHitDirection = matInvCharacter.TransformVectorOLD(DecalLCS.vHitDirection);
pChar->CreateDecal(DecalLCS);
}
}
// make decal on static entity component
if(m_pDecalManager)
{
CryEngineDecalInfo DecalInfoFixed = DecalInfo;
if(DecalInfo.pDecalOwner)
{ // try to find at least one marked to be visible static component
Matrix44 objMat, objMatInv;
int nPartID = DecalInfo.nPartID;
IStatObj * pEntObject = DecalInfo.pDecalOwner->GetEntityStatObj(nPartID, &objMat, true);
while(!pEntObject && nPartID<16)
{ // find first visible entity component
pEntObject = DecalInfo.pDecalOwner->GetEntityStatObj(++nPartID, &objMat, true);
}
if(!pEntObject)
return;
DecalInfoFixed.nPartID = nPartID;
}
m_pDecalManager->Spawn( DecalInfoFixed, m_fMaxViewDist, GetTerrain() );
}
}
ICryCharInstance * C3DEngine::MakeCharacter(const char * cid_file_name, unsigned int dwFlags)
{
ICryCharManager* pCharManager = GetSystem()->GetIAnimationSystem();
assert(pCharManager);
// NOTE: The returned class is not necessarily CryCharInstance. It can be AnimObject as well
return pCharManager->MakeCharacter(cid_file_name, dwFlags);
}
void C3DEngine::RemoveCharacter(ICryCharInstance * pCryCharInstance)
{
ICryCharManager* pCharManager = GetSystem()->GetIAnimationSystem();
if(pCryCharInstance && pCharManager)
pCharManager->RemoveCharacter(pCryCharInstance);
}
/*
float C3DEngine::GetDayTime(float fPrevDayTime)
{
if(fPrevDayTime)
{
float fDayTimeDiff = (GetCVars()->e_day_time - fPrevDayTime);
while(fDayTimeDiff>12)
fDayTimeDiff-=12;
while(fDayTimeDiff<-12)
fDayTimeDiff+=12;
fDayTimeDiff = (float)fabs(fDayTimeDiff);
return fDayTimeDiff;
}
return GetCVars()->e_day_time;
} */
void C3DEngine::SetWorldColorRatio(float fWorldColorRatio)
{
m_fWorldColorRatio = fWorldColorRatio;
}
float C3DEngine::GetWorldColorRatio()
{
return m_fWorldColorRatio;
}
Vec3d C3DEngine::GetWorldColor(bool bScaled)
{
if(bScaled)
{
//*
Vec3d color;
color = m_vWorldColorConst*m_fWorldColorRatio;
if(color.x > 1.0f)
color.x = 1.0f;
if(color.y > 1.0f)
color.y = 1.0f;
if(color.z > 1.0f)
color.z = 1.0f;
return color;
//*/
// return m_vWorldColorConst*m_fWorldColorRatio;
}
else
return m_vWorldColorConst;
}
void C3DEngine::SetWorldColor(Vec3d vColor)
{
m_vWorldColorConst = vColor;
}
void C3DEngine::SetOutdoorAmbientColor(Vec3d vColor)
{
if (m_pObjManager)
m_pObjManager->m_vOutdoorAmbientColor = vColor;
}
float C3DEngine::GetTerrainElevation(float x, float y)
{
return m_pTerrain ? m_pTerrain->GetZApr(x, y) : 0;
}
float C3DEngine::GetTerrainZ(int x, int y)
{
if(x<0 || y<0 || x>=CTerrain::GetTerrainSize() || y>=CTerrain::GetTerrainSize())
{
// GetLog()->Log("C3DEngine::GetTerrainZ: values out of range %d, %d, %d", (int)m_pTerrain, x, y);
return BOTTOM_LEVEL;
}
return m_pTerrain ? m_pTerrain->GetZ(x, y) : 0;
}
int C3DEngine::GetHeightMapUnitSize()
{
return CTerrain::GetHeightMapUnitSize();
}
int C3DEngine::GetTerrainSize()
{
return CTerrain::GetTerrainSize();
}
float C3DEngine::GetMaxViewDist()
{
return m_fMaxViewDist;
}
/*
bool C3DEngine::AddStaticObject(const char * szFileName, const Vec3d & vPos, const float fScale)
{
if(!m_pTerrain)
return 0;
return m_pTerrain->AddStaticObject(szFileName, vPos, fScale, m_pObjManager);
} */
bool C3DEngine::AddStaticObject(int nObjectID, const Vec3d & vPos, const float fScale, uchar ucBright)
{
if(!m_pTerrain)
return 0;
return m_pTerrain->AddStaticObject(nObjectID, vPos, fScale, m_pObjManager, ucBright);
}
bool C3DEngine::RemoveStaticObject(int nObjectID, const Vec3d & vPos)
{
if(!m_pTerrain)
return 0;
return m_pTerrain->RemoveStaticObject(nObjectID, vPos, m_pObjManager);
}
#ifdef WIN64
#pragma warning( push ) //AMD Port
#pragma warning( disable : 4311 )
#endif
bool C3DEngine::PhysicalizeStaticObject(void *pForeignData,int iForeignData,int iForeignFlags)
{
if (!m_pTerrain || !m_pObjManager)
return false;
int ix=(int)pForeignData&0xFF, iy=(int)pForeignData>>8&0xFF, iobj=(int)pForeignData>>16&0xFFFF;
return 0;//m_pObjManager->PhysicalizeStatObjInst( &m_pTerrain->m_arrSecInfoTable[ix][iy]->m_lstStatObjects[iobj], true );
}
#ifdef WIN64
#pragma warning( pop ) //AMD Port
#endif
void C3DEngine::RemoveAllStaticObjects()
{
if(!m_pTerrain)
return;
// m_pObjManager->DeletePhysicalEntitys();
m_pTerrain->RemoveAllStaticObjects();
}
int C3DEngine::GetTerrainSurfaceType(int x, int y)
{
if(m_pTerrain)
return m_pTerrain->GetSurfaceType(x,y);
return -1;
}
void C3DEngine::SetTerrainSurfaceType(int x, int y, int nType)
{
if(m_pTerrain)
m_pTerrain->SetSurfaceType(x,y,nType);
}
void C3DEngine::SetTerainHightMapBlock(int x1, int y1, int nSizeX, int nSizeY, ushort * TerrainBlock, ushort nUpdateMask)
{
if(m_pTerrain)
m_pTerrain->SetTerainHightMapBlock(x1, y1, nSizeX, nSizeY, TerrainBlock, nUpdateMask);
}
int C3DEngine::LockTerrainSectorTexture(int nSectorOriginX, int nSectorOriginY, int & nTexDim)
{
return m_pTerrain ? m_pTerrain->LockSectorTexture(nSectorOriginX, nSectorOriginY, nTexDim) : 0;
}
void C3DEngine::OnExplosion(Vec3d vPos, Vec3 vHitDir, float fRadius, int nTexID, bool bDeformTerrain)
{
if(vPos.x<0 || vPos.x>=CTerrain::GetTerrainSize())
return;
if(vPos.y<0 || vPos.y>=CTerrain::GetTerrainSize())
return;
// m_pBFManager->KillBF(vPos, fRadius);
// float fRadiusMinus = (vPos.z - GetTerrainZ((int)vPos.x,(int)vPos.y));
//if(fRadiusMinus < -1)
//return; // underground
// fRadius -= fRadiusMinus;
if(fRadius<=0)
return;
fRadius *= GetCVars()->e_explosion_scale;
// if(vPos.z <= GetWaterLevel())
// GetRenderer()->EF_AddSplash(vPos, EST_Water, fRadius);
//vPos+=Vec3d(1,1,0);
for(int x=int(vPos.x-fRadius); x<=int(vPos.x+fRadius)+1; x+=CTerrain::GetHeightMapUnitSize())
for(int y=int(vPos.y-fRadius); y<=int(vPos.y+fRadius)+1; y+=CTerrain::GetHeightMapUnitSize())
if(m_pTerrain->GetHoleSafe(x,y))
return;
bool bGroundBurnedOut = m_pTerrain->IsBurnedOut((int)vPos.x,(int)vPos.y);
float fHeight = (vPos.z - GetTerrainZ((int)vPos.x,(int)vPos.y));
if(m_pObjManager && !bGroundBurnedOut && fHeight>0 && fHeight<fRadius)
m_pTerrain->ExplodeTerrain(vPos,fRadius, m_pObjManager, bDeformTerrain);
list2<IEntityRender*> lstStaticsAround;
if(m_pTerrain)
m_pTerrain->GetObjectsAround(vPos, fRadius, &lstStaticsAround);
if(m_pVisAreaManager)
m_pVisAreaManager->GetObjectsAround(vPos, fRadius, &lstStaticsAround);
// make decals on the objects
for(int i=0; i<lstStaticsAround.Count(); i++)
{
CryEngineDecalInfo DecalInfo;
DecalInfo.vPos = vPos;
DecalInfo.vNormal = Vec3d(0,0,1);
DecalInfo.fSize = fRadius;//*0.6666f;
DecalInfo.fLifeTime = 120;
DecalInfo.nTid = nTexID;
DecalInfo.fAngle = float(rand()%36000)*0.01f;
DecalInfo.pDecalOwner = lstStaticsAround[i];
DecalInfo.nPartID = 0;
// DecalInfo.vHitDirection = ((vPos-GetViewCamera().GetPos()).GetNormalized()/*+vHitDir.GetNormalized()*/).GetNormalized();
DecalInfo.bAdjustPos = false;
CreateDecal( DecalInfo );
}
// make decal on the ground
if(!bGroundBurnedOut && fHeight<fRadius && fHeight>-0.5)
{
CryEngineDecalInfo DecalInfo;
DecalInfo.vPos = vPos - Vec3d(0,0,fHeight);
DecalInfo.vNormal = Vec3d(0,0,1);
DecalInfo.fSize = fRadius-fHeight;
DecalInfo.fLifeTime = 120;
DecalInfo.nTid = nTexID;
DecalInfo.fAngle = float(rand()%36000)*0.01f;
DecalInfo.bAdjustPos = false;
CreateDecal( DecalInfo );
}
}
void C3DEngine::SetSkyBox(const char * szSkyBoxShaderName)
{
SAFE_RELEASE(m_pSHSky);
m_pSHSky = szSkyBoxShaderName[0] ? GetRenderer()->EF_LoadShader(szSkyBoxShaderName, eSH_World) : NULL;
}
/*
int C3DEngine::GetMapPreviewTexID()
{
return (m_pTerrain && m_pTerrain->m_pMapPreviewTex) ? m_pTerrain->m_pMapPreviewTex->GetTextureID() : 0;
} */
void C3DEngine::SetScreenShader(const char * szShaderName)
{
if(szShaderName)
m_pSHFullScreenQuad = GetRenderer()->EF_LoadShader(szShaderName, eSH_World, EF_SYSTEM);
else
m_pSHFullScreenQuad = NULL;
}
void C3DEngine::SetMaxViewDistance(float fMaxViewDistance)
{
m_fMaxViewDist = fMaxViewDistance;
}
float C3DEngine::GetMaxViewDistance( )
{
return m_fMaxViewDist;
}
/*
void C3DEngine::SetFogParams(float fFogStart, float fFogEnd, Vec3d vFogColor)
{
m_fFogNearDist = fFogStart;
m_fFogFarDist = fFogEnd;
m_vFogColor = vFogColor;
} */
void C3DEngine::SetFogColor(const Vec3d& vFogColor)
{
m_vFogColor = vFogColor;
}
void C3DEngine::SetFogStart(const float fFogStart)
{
m_fFogNearDist = fFogStart;
}
void C3DEngine::SetFogEnd(const float fFogEnd)
{
m_fFogFarDist = fFogEnd;
}
Vec3d C3DEngine::GetFogColor( )
{
return m_vFogColor;
}
float C3DEngine::GetFogStart( )
{
return m_fFogNearDist;
}
float C3DEngine::GetFogEnd( )
{
return m_fFogFarDist;
}
/*
void C3DEngine::GetFogAndViewDistance(float & fFogStart, float & fFogEnd, Vec3d & vFogColor, float & fMaxViewDistance, bool bGetDefaultValues)
{
if(bGetDefaultValues)
{
fFogStart = m_fDefFogNearDist;
fFogEnd = m_fDefFogFarDist ;
vFogColor = m_vDefFogColor ;
fMaxViewDistance = m_fDefMaxViewDist;
}
else
{
fFogStart = m_fFogNearDist;
fFogEnd = m_fFogFarDist ;
vFogColor = m_vFogColor ;
fMaxViewDistance = m_fMaxViewDist;
}
} */
void C3DEngine::SetPhysMaterialEnumerator(IPhysMaterialEnumerator * pPhysMaterialEnumerator)
{
m_pPhysMaterialEnumerator = pPhysMaterialEnumerator;
}
IPhysMaterialEnumerator * C3DEngine::GetPhysMaterialEnumerator()
{
return m_pPhysMaterialEnumerator;
}
/*
IIndoorBase * C3DEngine::GetBuildingManager()
{
return 0;
} */
/*bool C3DEngine::IsPointInShadow(Vec3d vPos)
{
return m_pTerrain ? m_pTerrain->IsOnTheLight((int)vPos.x,(int)vPos.y)==0 : true;
} */
bool C3DEngine::IsPointInWater(Vec3d vPos)
{
// TODO: test indoors aslo
return vPos.z < GetWaterLevel(&vPos);
}
void C3DEngine::ApplyForceToEnvironment(Vec3d vPos, float fRadius, float fAmountOfForce)
{
if(m_pTerrain)
m_pTerrain->ApplyForceToEnvironment(vPos, fRadius, fAmountOfForce);
}
void BlurImage24(byte * pImage, int nSize, int nPassesNum)
{
#define DATA_TMP(_x,_y,_c) (pTemp [((_x)+nSize*(_y))*3+_c])
#define DATA_IMG(_x,_y,_c) (pImage[((_x)+nSize*(_y))*3+_c])
byte * pTemp = new byte [nSize*nSize*3];
for(int nPass=0; nPass<nPassesNum; nPass++)
{
memcpy(pTemp,pImage,nSize*nSize*3);
for(int x=1; x<nSize-1; x++)
for(int y=1; y<nSize-1; y++)
for(int c=0; c<3; c++)
{
float fVal = 0;
fVal += DATA_TMP(x,y,c);
fVal += DATA_TMP(x+1,y+1,c);
fVal += DATA_TMP(x-1,y+1,c);
fVal += DATA_TMP(x+1,y-1,c);
fVal += DATA_TMP(x-1,y-1,c);
DATA_IMG(x,y,c) = uchar(fVal*0.2f);
}
}
delete [] pTemp;
#undef DATA_IMG
#undef DATA_TMP
}
bool C3DEngine::MakeSectorLightMap(int nSectorOriginX, int nSectorOriginY, uchar * pImage, int nImageSize)
{
// reset to white
if(pImage)
for(int i=0; i<nImageSize*nImageSize*3; i++)
pImage[i] = 255;
if(!m_pTerrain)
return false;
// remove all lsources
while(m_lstDynLights.Count())
{
CDLight *pLight = &m_lstDynLights[0];
FreeLightSourceComponents(pLight);
m_lstDynLights.Delete(0);
}
// add sun lsource into light manager
UpdateScene(false,true);
// register sun in renderer
GetRenderer()->EF_ClearLightsList();
UpdateLightSources();
PrepareLightSourcesForRendering();
// only sun should be
int nRealLightsNum = ((C3DEngine*)Get3DEngine())->GetRealLightsNum();
assert(nRealLightsNum==1);
// increase frame id to help shadow map manager in renderer
unsigned short * pPtr2FrameID = (unsigned short *)GetRenderer()->EF_Query(EFQ_Pointer2FrameID);
if(pPtr2FrameID)
(*pPtr2FrameID)++;
if(nImageSize>GetRenderer()->GetWidth() || nImageSize>(float)GetRenderer()->GetHeight())
{
if(!m_bTerrainLightMapGenError)
Warning( 0,0,
"C3DEngine::MakeSectorLightMap: Requested image size is bigger than size of current renderer window."
"Please select lower resolution for terrain texture.");
m_bTerrainLightMapGenError = true;
return false;
}
if(!GetCVars()->e_shadow_maps)
{
m_bTerrainLightMapGenError = true;
return false;
}
GetLog()->Log("Building shadow map for sector %d-%d ... ", nSectorOriginX, nSectorOriginY);
GetRenderer()->BeginFrame();
{
GetRenderer()->ResetToDefault();
GetRenderer()->ClearDepthBuffer();
GetRenderer()->ClearColorBuffer(Vec3d(1,1,1));
GetRenderer()->SetClearColor(Vec3d(1,1,1));
GetRenderer()->SetViewport(0,0,nImageSize,nImageSize);
GetRenderer()->PushMatrix();
GetRenderer()->Set2DMode(true,int(CTerrain::GetSectorSize()),int(CTerrain::GetSectorSize()));
float fHalfPixelSize = (float(CTerrain::GetSectorSize())/nImageSize)*0.5f;
GetRenderer()->TranslateMatrix(-(float)nSectorOriginX-fHalfPixelSize, -(float)nSectorOriginY-fHalfPixelSize, 0);
{
for(int x=0; x<CTerrain::GetSectorsTableSize(); x++)
for(int y=0; y<CTerrain::GetSectorsTableSize(); y++)
{
CSectorInfo * pSecInfo = m_pTerrain->GetSecInfo(x*CTerrain::GetSectorSize(), y*CTerrain::GetSectorSize());
if(pSecInfo)
{
pSecInfo->ReleaseHeightMapVertBuffer();
pSecInfo->m_cGeometryMML=0;
pSecInfo->m_fDistance=0;
}
}
}
list2<struct IEntityRender*> lstAllEntities;
CSectorInfo * pSecInfo = m_pTerrain->GetSecInfo(nSectorOriginX, nSectorOriginY);
if(pSecInfo)
{
// setup vertex container
pSecInfo->m_cGeometryMML=0;
pSecInfo->m_fDistance=0;
// prepare terrain geometry
GetRenderer()->EF_StartEf();
pSecInfo->RenderSector(GetIdentityCCObject());
GetRenderer()->EF_EndEf3D(0);
GetRenderer()->ResetToDefault();
GetRenderer()->ClearDepthBuffer();
GetRenderer()->ClearColorBuffer(Vec3d(1,0,1));
GetRenderer()->SetClearColor(Vec3d(1,1,1));
// fill list with entities in this sector and neighbor sectors
if(pSecInfo)
{
lstAllEntities.AddList(pSecInfo->m_lstEntities[STATIC_ENTITIES]);
// get 2d bbox of sector
Vec3d vSecBoxMin( (float)pSecInfo->m_nOriginX,
(float)pSecInfo->m_nOriginY,0);
Vec3d vSecBoxMax( (float)pSecInfo->m_nOriginX+CTerrain::GetSectorSize(),
(float)pSecInfo->m_nOriginY+CTerrain::GetSectorSize(),512);
// get 2d bounds in sectors array
int min_x = (int)(((vSecBoxMin.x - 16.f)/CTerrain::GetSectorSize()));
int min_y = (int)(((vSecBoxMin.y - 16.f)/CTerrain::GetSectorSize()));
int max_x = (int)(((vSecBoxMax.x + 16.f)/CTerrain::GetSectorSize()));
int max_y = (int)(((vSecBoxMax.y + 16.f)/CTerrain::GetSectorSize()));
// limit bounds
if(min_x<0) min_x=0; else if(min_x>=CTerrain::GetSectorsTableSize()) min_x=CTerrain::GetSectorsTableSize()-1;
if(min_y<0) min_y=0; else if(min_y>=CTerrain::GetSectorsTableSize()) min_y=CTerrain::GetSectorsTableSize()-1;
if(max_x<0) max_x=0; else if(max_x>=CTerrain::GetSectorsTableSize()) max_x=CTerrain::GetSectorsTableSize()-1;
if(max_y<0) max_y=0; else if(max_y>=CTerrain::GetSectorsTableSize()) max_y=CTerrain::GetSectorsTableSize()-1;
list2<CSectorInfo*> lstTmpSectors;
lstTmpSectors.Add(m_pTerrain->m_arrSecInfoTable[0][0]);
for(int x=min_x; x<=max_x && x>=0 && x<=CTerrain::GetTerrainSize(); x++)
for(int y=min_y; y<=max_y && y>=0 && y<=CTerrain::GetTerrainSize(); y++)
{
CSectorInfo * pSectorInfo = m_pTerrain->m_arrSecInfoTable[x][y];
if(pSectorInfo != m_pTerrain->m_arrSecInfoTable[0][0])
lstTmpSectors.Add(pSectorInfo);
}
for(int s=0; s<lstTmpSectors.Count(); s++)
{
CSectorInfo * pSectorInfo = lstTmpSectors[s];
for(int e=0; e<pSectorInfo->m_lstEntities[STATIC_ENTITIES].Count(); e++)
{
IEntityRender * pEnt = pSectorInfo->m_lstEntities[STATIC_ENTITIES][e];
if(!(pEnt->GetRndFlags() & ERF_HIDDEN))
if(pEnt->GetRndFlags() & ERF_CASTSHADOWINTOLIGHTMAP)
if(!pEnt->GetEntityVisArea())
{
Vec3d vEntBoxMin,vEntBoxMax;
pEnt->GetRenderBBox(vEntBoxMin,vEntBoxMax);
Vec3d vRadius(pEnt->GetRenderRadius(),pEnt->GetRenderRadius(),pEnt->GetRenderRadius());
if(Overlap::AABB_AABB(AABB(vEntBoxMin,vEntBoxMax), AABB(vSecBoxMin-vRadius,vSecBoxMax+vRadius))
&& lstAllEntities.Find(pEnt)<0)
lstAllEntities.Add(pEnt);
}
}
}
}
GetLog()->LogPlus("%d casters found ... ", lstAllEntities.Count());
GetRenderer()->ResetToDefault();
GetRenderer()->ClearDepthBuffer();
GetRenderer()->ClearColorBuffer(Vec3d(1,0,1));
GetRenderer()->SetClearColor(Vec3d(1,1,1));
m_pObjManager->DrawAllShadowsOnTheGroundInSector(&lstAllEntities);
}
pSecInfo->m_cGeometryMML = 0;
pSecInfo->m_pCurShader = m_pTerrain->m_pTerrainEf;
GetRenderer()->Set2DMode(false,CTerrain::GetSectorSize(),CTerrain::GetSectorSize());
GetRenderer()->PopMatrix();
if(lstAllEntities.Count())
{
GetLog()->LogPlus("reading frame buffer ... ");
if(pImage)
GetRenderer()->ReadFrameBuffer(pImage, nImageSize, nImageSize, true, false);
bool bImageFound=false;
if(pImage)
for(int i=1; i<nImageSize*nImageSize*3; i++)
if(pImage[i]!=pImage[i-1])
bImageFound = true;
if(bImageFound && pImage)
{
GetLog()->LogPlus("blur image ... ");
BlurImage24(pImage, nImageSize, 1);
}
/* {
char sFileName[128];
snprintf(sFileName,128,"lmap-%d-%d.tga",nSectorOriginX, nSectorOriginY);
if(bImageFound)
GetRenderer()->SaveTga(pImage,24,nImageSize,nImageSize,sFileName,0);
else
remove(sFileName);
}*/
}
}
GetRenderer()->Update();
GetLog()->LogPlus("done");
return true;
}
float C3DEngine::GetDistanceToSectorWithWater()
{
CSectorInfo * pSectorInfo = NULL;
if(m_pTerrain)
pSectorInfo = m_pTerrain->GetSecInfo(GetViewCamera().GetPos());
return (pSectorInfo && (m_pTerrain->m_fDistanceToSectorWithWater > 0.1f))
? m_pTerrain->m_fDistanceToSectorWithWater : max(GetViewCamera().GetPos().z - GetWaterLevel(),0.1f);
}
void C3DEngine::SetSkyBoxAlpha(float fAlpha)
{
if(m_pRESky)
m_pRESky->m_fAlpha = fAlpha;
}
void C3DEngine::SetBFCount(int nCount)
{
Warning(0,0,"C3DEngine::SetBFCount: butterflies are not supported by 3dengine anymore, plz use boids entity instead");
// if(m_pBFManager)
// m_pBFManager->SetCount(nCount);
}
int C3DEngine::GetBFCount()
{
return 0;//m_pBFManager ? m_pBFManager->GetCount() : 0;
}
void C3DEngine::SetGrasshopperCGF( int nSlot, IStatObj * pStatObj )
{
GetLog()->Log("Warning: I3DEngine::SetGrasshopperCGF: Feature not supported anymore");
// if(m_pTerrain && m_pTerrain->m_pBugsManager)
// m_pTerrain->m_pBugsManager->SetCGF( nSlot, pStatObj );
}
void C3DEngine::SetGrasshopperCount(int nCount)
{
GetLog()->Log("Warning: I3DEngine::SetGrasshopperCount: Feature not supported anymore");
// if(m_pTerrain && m_pTerrain->m_pBugsManager)
// m_pTerrain->m_pBugsManager->SetCount(nCount);
}
int C3DEngine::GetGrasshopperCount()
{
GetLog()->Log("Warning: I3DEngine::GetGrasshopperCount: Feature not supported anymore");
return 0;//(m_pTerrain && m_pTerrain->m_pBugsManager) ? m_pTerrain->m_pBugsManager->GetCount() : 0;
}
Vec3d C3DEngine::GetOutdoorAmbientColor()
{
return m_pObjManager ? m_pObjManager->m_vOutdoorAmbientColor : Vec3d(0,0,0);
}
Vec3d C3DEngine::GetSunColor()
{
return m_pObjManager ? m_pObjManager->m_vSunColor : Vec3d(0,0,0);
}
Vec3d C3DEngine::GetSunPosition(bool bMoveUp)
{
if(bMoveUp)
{
Vec3d vSunPosition = m_vSunPosition;
vSunPosition.Normalize();
vSunPosition.z+=0.5f;
vSunPosition*=10000.0f;
return vSunPosition;
}
return m_vSunPosition;
}
Vec3d C3DEngine::GetAmbientColorFromPosition(const Vec3d & vPos, float fRadius)
{
if(m_pObjManager)
{
if(CVisArea * pVisArea = (CVisArea *)m_pVisAreaManager->GetVisAreaFromPos(vPos))
return pVisArea->m_vAmbColor+pVisArea->m_vDynAmbColor; // indooor
return m_pObjManager->m_vOutdoorAmbientColor;
}
return Vec3d(0,0,0); // undefined outdoor
}
uint C3DEngine::GetLightMaskFromPosition(const Vec3d & vPos, float fRadius)
{
// if(CVisArea * pVisArea = (CVisArea *)m_pVisAreaManager->GetVisAreaFromPos(vPos))
// return pVisArea->m_vAmbColor; // indooor
if(!m_pTerrain)
return 0;
if(fRadius > (float)CTerrain::GetSectorSize())
fRadius = (float)CTerrain::GetSectorSize();
CSectorInfo *pSectorInfo0 = m_pTerrain->GetSecInfo(vPos);
CSectorInfo *pSectorInfo1=0,*pSectorInfo2=0,*pSectorInfo3=0,*pSectorInfo4=0;
if (fRadius != 0)
{
pSectorInfo1 = m_pTerrain->GetSecInfo(vPos+Vec3d( fRadius, 0,0));
pSectorInfo2 = m_pTerrain->GetSecInfo(vPos+Vec3d( 0, fRadius,0));
pSectorInfo3 = m_pTerrain->GetSecInfo(vPos+Vec3d(-fRadius, 0,0));
pSectorInfo4 = m_pTerrain->GetSecInfo(vPos+Vec3d( 0,-fRadius,0));
}
uint nMask = 0;
if(GetRenderer()->EF_GetHeatVision())
{
nMask |= pSectorInfo0 ? pSectorInfo0->m_nDynLightMaskNoSun : 0;
nMask |= pSectorInfo1 ? pSectorInfo1->m_nDynLightMaskNoSun : 0;
nMask |= pSectorInfo2 ? pSectorInfo2->m_nDynLightMaskNoSun : 0;
nMask |= pSectorInfo3 ? pSectorInfo3->m_nDynLightMaskNoSun : 0;
nMask |= pSectorInfo4 ? pSectorInfo4->m_nDynLightMaskNoSun : 0;
}
else
{
nMask |= pSectorInfo0 ? pSectorInfo0->m_nDynLightMask : 0;
nMask |= pSectorInfo1 ? pSectorInfo1->m_nDynLightMask : 0;
nMask |= pSectorInfo2 ? pSectorInfo2->m_nDynLightMask : 0;
nMask |= pSectorInfo3 ? pSectorInfo3->m_nDynLightMask : 0;
nMask |= pSectorInfo4 ? pSectorInfo4->m_nDynLightMask : 0;
}
assert(nMask>=0);
if(!nMask)
{
nMask = GetFullLightMask();
// int nTmp = GetCVars()->e_max_entity_lights;
// GetCVars()->e_max_entity_lights = 8;
CheckDistancesToLightSources(nMask, vPos, fRadius);
//GetCVars()->e_max_entity_lights = nTmp;
}
return nMask;
}
bool C3DEngine::IsBoxVisibleOnTheScreen(const Vec3d & vBoxMin, const Vec3d & vBoxMax, OcclusionTestClient * pOcclusionTestClient )
{
// frustum test
if(!GetViewCamera().IsAABBVisibleFast( AABB(vBoxMin,vBoxMax) ))
return false;
// check visibility of outdoor sectors where this box is
// get 2d bounds in sectors array
int min_x = (int)(((vBoxMin.x - 1.f)/CTerrain::GetSectorSize()));
int min_y = (int)(((vBoxMin.y - 1.f)/CTerrain::GetSectorSize()));
int max_x = (int)(((vBoxMax.x + 1.f)/CTerrain::GetSectorSize()));
int max_y = (int)(((vBoxMax.y + 1.f)/CTerrain::GetSectorSize()));
if(min_x<0) min_x=0;
if(min_y<0) min_y=0;
if(max_x>=CTerrain::GetSectorsTableSize()) max_x = CTerrain::GetSectorsTableSize()-1;
if(max_y>=CTerrain::GetSectorsTableSize()) max_y = CTerrain::GetSectorsTableSize()-1;
// this test is valid only if entire bbox is in the map
if( min_x>=0 && max_x<CTerrain::GetSectorsTableSize() ||
min_y>=0 && max_y<CTerrain::GetSectorsTableSize() )
{ // if some sector was visible in last 5 sec - box is visible
for(int x=min_x; x<=max_x; x++)
for(int y=min_y; y<=max_y; y++)
{ // if some sector was visible in last 5 sec - box is visible
if(!GetCVars()->e_terrain ||
(GetTimer()->GetCurrTime() - m_pTerrain->m_arrSecInfoTable[x][y]->GetLastTimeUsed()) < 3.f)
{
if( pOcclusionTestClient )
{ // test terrain and objects (cbuffer) occlusion
float fDist = GetDistance( (vBoxMin + vBoxMax)*0.5f, GetViewCamera().GetPos());
if( m_pObjManager->IsBoxOccluded(vBoxMin,vBoxMax,fDist,pOcclusionTestClient) )
return false;
}
return true; // sector is visible
}
}
return false; // no sectors was rendered in last seconds
}
return true;
}
bool C3DEngine::IsSphereVisibleOnTheScreen(const Vec3d & vPos, const float fRadius, OcclusionTestClient * pOcclusionTestClient )
{
return IsBoxVisibleOnTheScreen(
vPos - Vec3d(fRadius,fRadius,fRadius),
vPos + Vec3d(fRadius,fRadius,fRadius),
pOcclusionTestClient );
}
IEntityRenderState * C3DEngine::MakeEntityRenderState()
{
return new IEntityRenderState;
}
void C3DEngine::FreeEntityRenderState(IEntityRender * pEntityRnd)
{
// GetLog()->Log("vlad: C3DEngine::FreeEntityRenderState: %d, %s", (int)(IEntityRender*)pEntityRnd, pEntityRnd->GetName());
/*
LightMapInfo * pLightMapInfo = (LightMapInfo *)pEntityRnd->GetLightMapInfo();
if(pLightMapInfo && pLightMapInfo->pLMTCBuffer)
GetRenderer()->ReleaseBuffer(pLightMapInfo->pLMTCBuffer);
*/
// TODO: Delete data here, or at a more appropiate place
// (currently done in CBrush::~CBrush(), hope that is 'a more appropiate place')
RemoveEntityLightSources(pEntityRnd);
if(m_pDecalManager)
m_pDecalManager->OnEntityDeleted(pEntityRnd);
if(m_pPartManager)
m_pPartManager->OnEntityDeleted(pEntityRnd);
GetRenderer()->OnEntityDeleted(pEntityRnd);
/*
#ifdef _DEBUG
UnRegisterInAllSectors(pEntityRnd);
#else*/
UnRegisterEntity(pEntityRnd);
//#endif
IEntityRenderState * pEntRendState = pEntityRnd->GetEntityRS();
if(!pEntRendState)
return;
if(pEntRendState->pShadowMapInfo)
{
pEntRendState->pShadowMapInfo->Release(pEntityRnd->GetEntityRenderType(), GetRenderer());
pEntRendState->pShadowMapInfo = NULL;
}
// check that was really unregistered
/* if(pEntityRnd->m_pSector)
for(int t=0; t<2; t++)
{
for(int e=0; e<pEntityRnd->m_pSector->m_lstEntities[t].Count(); e++)
{
if(pEntityRnd->m_pSector->m_lstEntities[t][e]->GetEntityRS() == pEntRendState)
{
assert(0); // UnRegisterInAllSectors do this already
pEntityRnd->m_pSector->m_lstEntities[t].Delete(e);
}
}
pEntityRnd->m_pSector->m_lstEntities[t].Delete(pEntityRnd);
}
pEntityRnd->m_pSector = 0;
*/
// delete occlusion client
/* for(int i=0; i<2; i++)
if(pEntRendState->pOcclState && pEntRendState->pOcclState->arrREOcclusionQuery[i])
{
pEntRendState->pOcclState->arrREOcclusionQuery[i]->Release();
pEntRendState->pOcclState->arrREOcclusionQuery[i] = 0;
}*/
// delete pEntRendState->pOcclState;
//pEntRendState->pOcclState = 0;
//todo: is it needed?
// pEntityRnd->m_pVisArea = 0;
delete pEntRendState;
pEntityRnd->GetEntityRS()=0;
}
#ifdef WIN64
#pragma warning( push ) //AMD Port
#pragma warning( disable : 4267 )
#endif
//////////////////////////////////////////////////////////
// checks whether the given file is a character file
// returns true if it is
//////////////////////////////////////////////////////////
bool C3DEngine::IsCharacterFile(const char * szCGFileName)
{
FILE * f = GetSystem()->GetIPak()->FOpen(szCGFileName,"rb");
if(!f)
return false;
//read the file header
FILE_HEADER fh;
int res = GetSystem()->GetIPak()->FRead(&fh,sizeof(fh),1,f);
if(res!=1)
{
GetSystem()->GetIPak()->FClose(f);
return false;
}
if(fh.Version != GeomFileVersion || fh.FileType != FileType_Geom)
{
GetSystem()->GetIPak()->FClose(f);
return false;
}
//read the chunk table
GetSystem()->GetIPak()->FSeek(f,fh.ChunkTableOffset,SEEK_SET);
int n_chunks;
res = GetSystem()->GetIPak()->FRead(&n_chunks,sizeof(n_chunks),1,f);
if(res!=1)
{
GetSystem()->GetIPak()->FClose(f);
return false;
}
CHUNK_HEADER * arrChunks = new CHUNK_HEADER [n_chunks];
res = GetSystem()->GetIPak()->FRead(arrChunks,sizeof(CHUNK_HEADER),n_chunks,f);
if(res!=n_chunks)
{
delete [] arrChunks;
GetSystem()->GetIPak()->FClose(f);
return false;
}
for(int i=0;i<n_chunks;i++)
{
switch (arrChunks[i].ChunkType)
{
case ChunkType_BoneNameList:
delete [] arrChunks;
GetSystem()->GetIPak()->FClose (f);
return true;
}
}
delete [] arrChunks;
GetSystem()->GetIPak()->FClose(f);
return false;
}
#ifdef WIN64
#pragma warning( pop ) //AMD Port
#endif
//////////////////////////////////////////////////////////////////////////
IParticleEmitter* C3DEngine::CreateParticleEmitter()
{
if (m_pPartManager)
return m_pPartManager->CreateEmitter();
return 0;
}
//////////////////////////////////////////////////////////////////////////
void C3DEngine::DeleteParticleEmitter(IParticleEmitter * pPartEmitter)
{
assert(pPartEmitter);
if (m_pPartManager)
m_pPartManager->DeleteEmitter(pPartEmitter);
}
const char * C3DEngine::GetLevelFilePath(const char * szFileName)
{
strcpy(m_sGetLevelFilePathTmpBuff, m_szLevelFolder);
strcat(m_sGetLevelFilePathTmpBuff, szFileName);
return m_sGetLevelFilePathTmpBuff;
}
ushort * C3DEngine::GetUnderWaterSmoothHMap(int & nDimensions)
{
return m_pTerrain ? m_pTerrain->GetUnderWaterSmoothHMap(nDimensions) : 0;
}
void C3DEngine::MakeUnderWaterSmoothHMap(int nWaterUnitSize)
{
if(m_pTerrain)
m_pTerrain->MakeUnderWaterSmoothHMap(nWaterUnitSize);
}
void C3DEngine::SetTerrainBurnedOut(int x, int y, bool bBurnedOut)
{
if(m_pTerrain)
{
m_pTerrain->SetBurnedOut(x, y, bBurnedOut);
// update vert buffers
CSectorInfo * pInfo = m_pTerrain->GetSecInfo(x,y);
if(pInfo)
pInfo->ReleaseHeightMapVertBuffer();
}
}
bool C3DEngine::IsTerrainBurnedOut(int x, int y)
{
return m_pTerrain ? m_pTerrain->IsBurnedOut(x, y) : 0;
}
void C3DEngine::UpdateDetailObjects()
{
if(m_pTerrain && m_pTerrain->m_pDetailObjects)
m_pTerrain->m_pDetailObjects->UpdateGrass();
}
int C3DEngine::GetTerrainSectorSize()
{
return m_pTerrain ? m_pTerrain->GetSectorSize() : 0;
}
void C3DEngine::AddWaterSplash (Vec3d vPos, eSplashType eST, float fForce, int Id=-1)
{
GetRenderer()->EF_AddSplash(vPos, eST, fForce, Id);
}
void C3DEngine::EnableHeatVision(bool bEnable)
{
GetRenderer()->EF_EnableHeatVision(bEnable);
}
void C3DEngine::ActivatePortal(const Vec3d &vPos, bool bActivate, IEntityRender *pEntity)
{
m_pVisAreaManager->ActivatePortal(vPos, bActivate, pEntity);
}
int C3DEngine::GetTerrainTextureDim()
{
return m_pTerrain ? m_pTerrain->GetTerrainTextureDim() : 0;
}
bool C3DEngine::SetStatInstGroup(int nGroupId, const IStatInstGroup & siGroup)
{
m_pObjManager->m_lstStaticTypes.PreAllocate(1024,1024);
if(nGroupId<0 || nGroupId>=m_pObjManager->m_lstStaticTypes.Count())
return false;
m_pObjManager->m_lstStaticTypes[nGroupId].pStatObj = (CStatObj*)siGroup.pStatObj;
if(siGroup.pStatObj)
siGroup.pStatObj->CheckValidVegetation();
m_pObjManager->m_lstStaticTypes[nGroupId].bHideability = siGroup.bHideability;
m_pObjManager->m_lstStaticTypes[nGroupId].bPhysNonColl = siGroup.bPhysNonColl;
m_pObjManager->m_lstStaticTypes[nGroupId].fBending = siGroup.fBending;
m_pObjManager->m_lstStaticTypes[nGroupId].bCastShadow = siGroup.bCastShadow;
m_pObjManager->m_lstStaticTypes[nGroupId].bRecvShadow = siGroup.bRecvShadow;
m_pObjManager->m_lstStaticTypes[nGroupId].bPrecShadow = siGroup.bPrecShadow;
m_pObjManager->m_lstStaticTypes[nGroupId].bUseAlphaBlending = siGroup.bUseAlphaBlending;
// m_pObjManager->m_lstStaticTypes[nGroupId].bTakeBrightnessFromLightBit = siGroup.bTakeBrightnessFromLightBit;
m_pObjManager->m_lstStaticTypes[nGroupId].fSpriteDistRatio = siGroup.fSpriteDistRatio;
m_pObjManager->m_lstStaticTypes[nGroupId].fShadowDistRatio = siGroup.fShadowDistRatio;
m_pObjManager->m_lstStaticTypes[nGroupId].fMaxViewDistRatio = siGroup.fMaxViewDistRatio;
m_pObjManager->m_lstStaticTypes[nGroupId].fBrightness = siGroup.fBrightness;
m_pObjManager->m_lstStaticTypes[nGroupId].bUpdateShadowEveryFrame = siGroup.bUpdateShadowEveryFrame;
// m_pObjManager->m_lstStaticTypes[nGroupId].fAmbScale = siGroup.fAmbScale;
m_pObjManager->m_lstStaticTypes[nGroupId].nSpriteTexRes = siGroup.nSpriteTexRes;
m_pObjManager->m_lstStaticTypes[nGroupId].pMaterial = siGroup.pMaterial;
m_pObjManager->m_lstStaticTypes[nGroupId].fBackSideLevel = siGroup.fBackSideLevel;
m_pObjManager->m_lstStaticTypes[nGroupId].bCalcLighting = siGroup.bCalcLighting;
m_pObjManager->m_lstStaticTypes[nGroupId].bUseSprites = siGroup.bUseSprites;
m_pObjManager->m_lstStaticTypes[nGroupId].bFadeSize = siGroup.bFadeSize;
m_pObjManager->m_lstStaticTypes[nGroupId].SetRndFlags();
return true;
}
bool C3DEngine::GetStatInstGroup(int nGroupId, IStatInstGroup & siGroup)
{
if(nGroupId<0 || nGroupId>=m_pObjManager->m_lstStaticTypes.Count())
return false;
siGroup.pStatObj = m_pObjManager->m_lstStaticTypes[nGroupId].pStatObj;
siGroup.bHideability = m_pObjManager->m_lstStaticTypes[nGroupId].bHideability;
siGroup.bPhysNonColl = m_pObjManager->m_lstStaticTypes[nGroupId].bPhysNonColl;
siGroup.fBending = m_pObjManager->m_lstStaticTypes[nGroupId].fBending;
siGroup.bCastShadow = m_pObjManager->m_lstStaticTypes[nGroupId].bCastShadow;
siGroup.bRecvShadow = m_pObjManager->m_lstStaticTypes[nGroupId].bRecvShadow;
siGroup.bPrecShadow = m_pObjManager->m_lstStaticTypes[nGroupId].bPrecShadow;
siGroup.bUseAlphaBlending = m_pObjManager->m_lstStaticTypes[nGroupId].bUseAlphaBlending;
// siGroup.bTakeBrightnessFromLightBit = m_pObjManager->m_lstStaticTypes[nGroupId].bTakeBrightnessFromLightBit;
siGroup.fSpriteDistRatio = m_pObjManager->m_lstStaticTypes[nGroupId].fSpriteDistRatio;
siGroup.fShadowDistRatio = m_pObjManager->m_lstStaticTypes[nGroupId].fShadowDistRatio;
siGroup.fMaxViewDistRatio = m_pObjManager->m_lstStaticTypes[nGroupId].fMaxViewDistRatio;
siGroup.fBrightness = m_pObjManager->m_lstStaticTypes[nGroupId].fBrightness;
siGroup.bUpdateShadowEveryFrame = m_pObjManager->m_lstStaticTypes[nGroupId].bUpdateShadowEveryFrame;
// siGroup.fAmbScale = m_pObjManager->m_lstStaticTypes[nGroupId].fAmbScale;
siGroup.nSpriteTexRes = m_pObjManager->m_lstStaticTypes[nGroupId].nSpriteTexRes;
siGroup.pMaterial = m_pObjManager->m_lstStaticTypes[nGroupId].pMaterial;
siGroup.fBackSideLevel = m_pObjManager->m_lstStaticTypes[nGroupId].fBackSideLevel;
siGroup.bCalcLighting = m_pObjManager->m_lstStaticTypes[nGroupId].bCalcLighting;
siGroup.bUseSprites = m_pObjManager->m_lstStaticTypes[nGroupId].bUseSprites;
return true;
}
void C3DEngine::GetMemoryUsage(class ICrySizer * pSizer)
{
if (!pSizer->Add(*this))
return; // we've already added this object
{
SIZER_COMPONENT_NAME(pSizer, "Particles");
if(m_pPartManager)
m_pPartManager->GetMemoryUsage(pSizer);
}
pSizer->AddContainer(m_lstDynLights);
{
// SIZER_COMPONENT_NAME(pSizer, "BFlies");
// pSizer->AddObject(m_pBFManager, m_pBFManager->GetMemoryUsage());
}
if(m_pConnectivityBuilder)
{
SIZER_COMPONENT_NAME(pSizer, "EdgeConnectivityBuilder");
m_pConnectivityBuilder->GetMemoryUsage(pSizer);
}
pSizer->AddObject(m_pCVars, sizeof(CVars));
if(m_pDecalManager)
{
SIZER_COMPONENT_NAME(pSizer, "DecalManager");
m_pDecalManager->GetMemoryUsage(pSizer);
pSizer->AddObject(m_pDecalManager, sizeof(*m_pDecalManager));
}
if(m_pShadowEdgeDetector)
{
SIZER_COMPONENT_NAME(pSizer, "ShadowEdgeDetector");
m_pShadowEdgeDetector->GetMemoryUsage(pSizer);
pSizer->AddObject(m_pShadowEdgeDetector, sizeof(*m_pShadowEdgeDetector));
}
if(m_pObjManager)
{
SIZER_COMPONENT_NAME(pSizer, "ObjManager");
pSizer->AddObject(m_pObjManager, sizeof(*m_pObjManager) + m_pObjManager->GetMemoryUsage(pSizer));
}
if (m_pTerrain)
{
SIZER_COMPONENT_NAME(pSizer, "Terrain");
m_pTerrain->GetMemoryUsage(pSizer);
}
if (m_pVisAreaManager)
{
SIZER_COMPONENT_NAME(pSizer, "VisAreas");
m_pVisAreaManager->GetMemoryUsage(pSizer);
}
}
float C3DEngine::GetWaterLevel(IEntityRender * pEntityRender, Vec3d * pvFlowDir)
{
// const char * pName = pEntityRender->GetEntityClassName();
if (pEntityRender && m_pObjManager && m_pObjManager->m_pCWaterVolumes && m_pObjManager->m_pTerrain)
{
IPhysicalEntity *pent = pEntityRender->GetPhysics();
pe_params_bbox pbb;
Vec3d pos;
if (pent && pent->GetParams(&pbb))
pos = (pbb.BBox[0]+pbb.BBox[1])*0.5f;
else
pos = pEntityRender->GetPos();
float fWaterVolumeLevel = m_pObjManager->m_pCWaterVolumes->GetWaterVolumeLevelFor2DPoint(pos, pvFlowDir);
return max(fWaterVolumeLevel, pEntityRender->GetEntityVisArea() ? WATER_LEVEL_UNKNOWN : m_pObjManager->m_pTerrain->GetWaterLevel());
}
if(m_pObjManager && m_pObjManager->m_pTerrain && pEntityRender && !pEntityRender->GetEntityVisArea())
return m_pObjManager->m_pTerrain->GetWaterLevel();
return WATER_LEVEL_UNKNOWN;
}
float C3DEngine::GetWaterLevel(const Vec3d * pvPos, Vec3d * pvFlowDir)
{
IVisArea * pArea = (pvPos && m_pVisAreaManager) ? m_pVisAreaManager->GetVisAreaFromPos(*pvPos) : 0;
if(m_pObjManager && pvPos && m_pObjManager->m_pCWaterVolumes && m_pObjManager->m_pTerrain)
{
float fWaterVolumeLevel = m_pObjManager->m_pCWaterVolumes->GetWaterVolumeLevelFor2DPoint(*pvPos, pvFlowDir);
return max(fWaterVolumeLevel, pArea ? WATER_LEVEL_UNKNOWN : m_pObjManager->m_pTerrain->GetWaterLevel());
}
if(m_pObjManager && m_pObjManager->m_pTerrain && !pArea)
return m_pObjManager->m_pTerrain->GetWaterLevel();
return WATER_LEVEL_UNKNOWN;
}
IWaterVolume * C3DEngine::CreateWaterVolume()
{
if(!m_pObjManager->m_pCWaterVolumes)
m_pObjManager->m_pCWaterVolumes = new CWaterVolumeManager();
if(m_pObjManager && m_pObjManager->m_pCWaterVolumes)
return m_pObjManager->m_pCWaterVolumes->CreateWaterVolume();
return 0;
}
void C3DEngine::DeleteWaterVolume(IWaterVolume * pWaterVolume)
{
if(m_pObjManager && m_pObjManager->m_pCWaterVolumes)
m_pObjManager->m_pCWaterVolumes->DeleteWaterVolume(pWaterVolume);
}
IWaterVolume * C3DEngine::FindWaterVolumeByName(const char * szName)
{
if(m_pObjManager && m_pObjManager->m_pCWaterVolumes)
return m_pObjManager->m_pCWaterVolumes->FindWaterVolumeByName(szName);
return 0;
}
IVisArea * C3DEngine::CreateVisArea()
{
return m_pObjManager ? m_pVisAreaManager->CreateVisArea() : 0;
}
void C3DEngine::DeleteVisArea(IVisArea * pVisArea)
{
if(!m_pVisAreaManager->IsValidVisAreaPointer((CVisArea*)pVisArea))
{
Warning( 0,0,"I3DEngine::DeleteVisArea: Invalid VisArea pointer");
return;
}
if(m_pObjManager)
{
((CVisArea*)pVisArea)->UnmakeAreaBrush();
list2<IEntityRender*> lstEntitiesInArea;
lstEntitiesInArea.AddList(((CVisArea*)pVisArea)->m_lstEntities[DYNAMIC_ENTITIES]);
lstEntitiesInArea.AddList(((CVisArea*)pVisArea)->m_lstEntities[STATIC_ENTITIES]);
for(int i=0; i<lstEntitiesInArea.Count(); i++)
Get3DEngine()->UnRegisterEntity(lstEntitiesInArea[i]);
assert(((CVisArea*)pVisArea)->m_lstEntities[STATIC_ENTITIES].Count()==0);
assert(((CVisArea*)pVisArea)->m_lstEntities[DYNAMIC_ENTITIES].Count()==0);
m_pVisAreaManager->DeleteVisArea((CVisArea*)pVisArea);
for(int i=0; i<lstEntitiesInArea.Count(); i++)
Get3DEngine()->RegisterEntity(lstEntitiesInArea[i]);
if(m_pObjManager->m_pCWaterVolumes)
m_pObjManager->m_pCWaterVolumes->UpdateWaterVolumeVisAreas();
}
}
void C3DEngine::UpdateVisArea(IVisArea * pVisArea,
const Vec3d * pPoints, int nCount,
const char * szName, float fHeight,
const Vec3d & vAmbientColor,
bool bAfectedByOutLights,
bool bSkyOnly, const Vec3 & vDynAmbientColor,
float fViewDistRatio, bool bDoubleSide, bool bUseDeepness, bool bUseInIndoors )
{
if(!m_pObjManager)
return;
CVisArea * pArea = (CVisArea*)pVisArea;
GetLog()->Log("C3DEngine::UpdateVisArea: %s", szName);
Vec3d vTotalBoxMin = pArea->m_vBoxMin;
Vec3d vTotalBoxMax = pArea->m_vBoxMax;
m_pVisAreaManager->UpdateVisArea((CVisArea*)pVisArea, pPoints, nCount, szName, fHeight, vAmbientColor, bAfectedByOutLights, bSkyOnly, m_pTerrain, vDynAmbientColor, fViewDistRatio, bDoubleSide, bUseDeepness, bUseInIndoors);
if(pArea->m_lstEntities[STATIC_ENTITIES].Count() || pArea->m_lstEntities[DYNAMIC_ENTITIES].Count())
{
// merge old and new bboxes
vTotalBoxMin.CheckMin(pArea->m_vBoxMin);
vTotalBoxMax.CheckMax(pArea->m_vBoxMax);
}
else
{
vTotalBoxMin = pArea->m_vBoxMin;
vTotalBoxMax = pArea->m_vBoxMax;
}
// if(strstr(szName, "VisArea8"))
// int y=0;
m_pObjManager->ReregisterEntitiesInArea(vTotalBoxMin - Vec3d(8,8,8), vTotalBoxMax + Vec3d(8,8,8));
if(m_pObjManager->m_pCWaterVolumes)
m_pObjManager->m_pCWaterVolumes->UpdateWaterVolumeVisAreas();
}
int C3DEngine::GetFogVolumeIdFromBBox(const Vec3d & vBoxMin, const Vec3d & vBoxMax)
{
for(int f=0; f<m_pTerrain->m_lstFogVolumes.Count(); f++)
{
const Vec3d & vVolMin = m_pTerrain->m_lstFogVolumes[f].vBoxMin;
const Vec3d & vVolMax = m_pTerrain->m_lstFogVolumes[f].vBoxMax;
if(vVolMax.x>vBoxMin.x && vBoxMax.x>vVolMin.x)
if(vVolMax.y>vBoxMin.y && vBoxMax.y>vVolMin.y)
if(vVolMax.z>vBoxMin.z && vBoxMax.z>vVolMin.z)
{
return m_pTerrain->m_lstFogVolumes[f].nRendererVolumeID;
}
}
return 0;
}
void C3DEngine::ResetParticlesAndDecals( )
{
if(m_pPartManager)
m_pPartManager->Reset();
if(m_pDecalManager)
m_pDecalManager->Reset();
if(GetSystem()->GetIAnimationSystem())
GetSystem()->GetIAnimationSystem()->ClearDecals();
}
IEntityRender * C3DEngine::CreateEntityRender()
{
CBrush * pBrush = new CBrush();
m_pObjManager->m_lstBrushContainer.Add(pBrush);
return pBrush;
}
IEntityRender * C3DEngine::CreateVegetation()
{
CStatObjInst * pVeget = new CStatObjInst();
m_pObjManager->m_lstVegetContainer.Add(pVeget);
return pVeget;
}
void C3DEngine::DeleteEntityRender(IEntityRender * pEntityRender)
{
UnRegisterEntity(pEntityRender);
m_pObjManager->m_lstBrushContainer.Delete((CBrush*)pEntityRender);
m_pObjManager->m_lstVegetContainer.Delete((CStatObjInst*)pEntityRender);
delete pEntityRender;
}
void C3DEngine::DrawRain()
{
Vec3d vWindDir = m_vWindForce;
vWindDir.z = -16.f - GetCVars()->e_rain_amount*16.f;
if(m_pRainManager && m_pTerrain)
m_pRainManager->Render(m_pTerrain, m_vFogColor, m_pObjManager, m_pPartManager, vWindDir);
}
void C3DEngine::SetRainAmount( float fAmount )
{
GetCVars()->e_rain_amount = max(min(1.f,fAmount),0);
}
void C3DEngine::SetWindForce( const Vec3d & vWindForce )
{
m_vWindForce = vWindForce;
}
float C3DEngine::GetAmbientLightAmountForEntity(IEntityRender * pEntity)
{
Vec3d vColor(0,0,0);
if(pEntity && pEntity->GetEntityVisArea())
vColor = ((CVisArea*)pEntity->GetEntityVisArea())->m_vAmbColor;
else if(m_pObjManager)
vColor = m_pObjManager->m_vOutdoorAmbientColor;
vColor.x *= m_vWorldColorConst.x;
vColor.y *= m_vWorldColorConst.y;
vColor.z *= m_vWorldColorConst.z;
return (vColor.x + vColor.y + vColor.z)*0.3333f;
}
float C3DEngine::GetLightAmountForEntity(IEntityRender * pEntity, bool bOnlyVisibleLights)
{
Vec3d vLightAmount(0,0,0);
uint dwDLightMask = (uint)-1; // check all lights
CheckDistancesToLightSources(dwDLightMask, pEntity->GetPos(), 1, pEntity, 16, 0, 0, &vLightAmount);
float fLightAmount = (vLightAmount.x+vLightAmount.y+vLightAmount.z)*0.233f;
return min(1.f,fLightAmount);
}
IVisArea * C3DEngine::GetVisAreaFromPos(const Vec3d &vPos)
{
if(m_pObjManager && m_pVisAreaManager)
return m_pVisAreaManager->GetVisAreaFromPos(vPos);
return 0;
}
bool C3DEngine::IsVisAreasConnected(IVisArea * pArea1, IVisArea * pArea2, int nMaxRecursion, bool bSkipDisabledPortals)
{
if (pArea1==pArea2)
return (true); // includes the case when both pArea1 & pArea2 are NULL (totally outside)
// not considered by the other checks
if (!pArea1 || !pArea2)
return (false); // avoid a crash - better to put this check only
// here in one place than in all the places where this function is called
nMaxRecursion *= 2; // include portals since portals are the areas
if(m_pObjManager && m_pVisAreaManager)
return ((CVisArea*)pArea1)->FindVisArea((CVisArea*)pArea2, nMaxRecursion, bSkipDisabledPortals);
return false;
}
#ifdef GAMECUBE
#define CRY_GCRENDER_API __declspec(export)
#ifdef __cplusplus
extern "C" {
#endif
typedef void (*voidfunctionptr) (void); // ptr to function returning void
__declspec(section ".init") extern voidfunctionptr _ctors[];
__declspec(section ".init") extern voidfunctionptr _dtors[];
void _prolog(void);
void _epilog(void);
void _unresolved(void);
#ifdef __cplusplus
}
#endif
//_prolog is the entrypoint to the module
// Called by the main application after the module is linked
// This executes the static constructors for the module.
// User code starts here.
CRY_GCRENDER_API void _prolog(void) {
// call static initializers
OSReport("Call Static Initializers\n");
voidfunctionptr *constructor;
for (constructor = _ctors; *constructor; constructor++) {
(*constructor)();
}
}
// _epilog is called before the the module is unlinked
// This executes the static destructors for the module.
CRY_GCRENDER_API void _epilog(void) {
voidfunctionptr *destructor;
for (destructor = _dtors; *destructor; destructor++) {
(*destructor)();
}
}
// _unresolved is called if a module attempts
// to call a symbol that is not present in another module.
// If _unresolved is not specified, the branch to the symbol
// will instead branch back to itself.
CRY_GCRENDER_API void _unresolved(void) {
u32 i;
u32* p;
OSReport("\nError: Unlinked function called in module %s.\n", __FILE__);
OSReport("Address: Back Chain LR Save\n");
for (i = 0, p = (u32*) OSGetStackPointer(); // get current sp
p && (u32) p != 0xffffffff && i++ < 16;
p = (u32*) *p) // get caller sp
{
OSReport("0x%08x: 0x%08x 0x%08x\n", p, p[0], p[1]);
}
OSReport("\n");
}
#endif //GAMECUBE
bool C3DEngine::IsOutdoorVisible()
{
if(m_pVisAreaManager)
return m_pVisAreaManager->IsOutdoorAreasVisible();
return false;
}
void C3DEngine::EnableOceanRendering(bool bOcean, bool bShore)
{
m_bOcean = bOcean;
m_bShore = bShore;
}
IMatInfo * C3DEngine::CreateMatInfo()
{
return m_pMatMan ? m_pMatMan->CreateMatInfo() : 0;
}
void C3DEngine::DeleteMatInfo(IMatInfo * pMatInfo)
{
m_pMatMan->DeleteMatInfo(pMatInfo);
}
void C3DEngine::RenameMatInfo( IMatInfo *pMtl,const char *sNewName )
{
m_pMatMan->RenameMatInfo(pMtl,sNewName);
}
IMatInfo* C3DEngine::FindMaterial( const char *sMaterialName )
{
return m_pMatMan->FindMatInfo( sMaterialName );
}
//////////////////////////////////////////////////////////////////////////
ILMSerializationManager * C3DEngine::CreateLMSerializationManager()
{
return new CLMSerializationManager2();
}
bool C3DEngine::IsOutdoorsVisible()
{
return (m_pObjManager && m_pVisAreaManager) ?
m_pVisAreaManager->IsOutdoorAreasVisible() : false;
}
bool C3DEngine::IsTerainHightMapModifiedByGame()
{
return m_pTerrain ? m_pTerrain->m_bHightMapModified : 0;
}
bool C3DEngine::IsPotentiallyVisible(IEntityRender * pEntityRender, float fAdditionalRadius )
{
if(!pEntityRender->GetEntityRS())
return false;
IVisArea * pVisArea = (IVisArea *)pEntityRender->m_pVisArea;
if(pVisArea)
{ // object is in indoors - test vis of current visarea
if ((GetFrameID() - pVisArea->GetVisFrameId())<2)
return true; // visible
if (fAdditionalRadius > 0)
{ // test neighbours
IVisArea * Areas[64];
int nCount = pVisArea->GetVisAreaConnections(Areas,64);
for (int i=0; i<nCount; i++)
if((GetFrameID() - Areas[i]->GetVisFrameId())<2)
return true; // visible
}
return false; // no areas visible
}
else if(m_pTerrain)
{ // object is in outdoors - test vis of terrain sectors
if (!GetCVars()->e_terrain)
return false;
Vec3d vBoxMin,vBoxMax;
pEntityRender->GetRenderBBox(vBoxMin,vBoxMax);
// check visibility of outdoor sectors where this box is
// get 2d bounds in sectors array
// todo: use ready list of terrain sectors from entity itself
float fSizePlus = 8.f + fAdditionalRadius;
float fInvSectorSize = 1.0f / CTerrain::GetSectorSize();
int min_x = fastftol_positive( (vBoxMin.x - fSizePlus)*fInvSectorSize );
int min_y = fastftol_positive( (vBoxMin.y - fSizePlus)*fInvSectorSize );
int max_x = fastftol_positive( (vBoxMax.x + fSizePlus)*fInvSectorSize );
int max_y = fastftol_positive( (vBoxMax.y + fSizePlus)*fInvSectorSize );
// can not test outside of the map
// this test is valid only if entire bbox is in the map
if(min_x<0) return true;
if(min_y<0) return true;
if(max_x>=CTerrain::GetSectorsTableSize()) return true;
if(max_y>=CTerrain::GetSectorsTableSize()) return true;
// OcclusionTestClient * pOcclusionTestClient = 0;
float currTime = GetTimer()->GetCurrTime();
// if some sector was visible in last 2 sec - box is visible
for(int x=min_x; x<=max_x; x++)
for(int y=min_y; y<=max_y; y++)
{
if ((currTime - m_pTerrain->m_arrSecInfoTable[x][y]->GetLastTimeRendered()) < LAST_POTENTIALLY_VISIBLE_TIME)
{
/* if( pOcclusionTestClient )
{ // test terrain and objects occlusion
float fDist = GetDistance( (vBoxMin + vBoxMax)*0.5f, GetViewCamera().GetPos());
if( m_pObjManager->IsBoxOccluded(vBoxMin,vBoxMax,fDist,pOcclusionTestClient) )
return false;
}*/
return true; // sector is visible
}
}
return false; // no sectors was rendered in last seconds
}
else
return false; // no outdoors present
}
IEdgeConnectivityBuilder *C3DEngine::GetNewConnectivityBuilder( void )
{
assert(m_pConnectivityBuilder);
m_pConnectivityBuilder->Reinit();
return(m_pConnectivityBuilder);
}
//! creates a connectivity object that can be used to deserialize the connectivity data
IStencilShadowConnectivity *C3DEngine::NewConnectivity()
{
return new CStencilShadowConnectivity();
}
IEdgeConnectivityBuilder *C3DEngine::GetNewStaticConnectivityBuilder( void )
{
assert(m_pStaticConnectivityBuilder);
m_pStaticConnectivityBuilder->Reinit();
return(m_pStaticConnectivityBuilder);
}
IEdgeDetector *C3DEngine::GetEdgeDetector( void )
{
return(m_pShadowEdgeDetector);
}
void C3DEngine::UpdateBeaches()
{
if(m_pTerrain)
m_pTerrain->InitBeaches(true);
}
void C3DEngine::RestoreTerrainFromDisk()
{
if(m_pTerrain && m_pObjManager)
{
m_pTerrain->ResetTerrainVertBuffers();
m_pTerrain->LoadHighMap(GetLevelFilePath(HEIGHT_MAP_FILE_NAME), GetSystem()->GetIPak());
// m_pTerrain->LoadStatObjInstances();
// m_pObjManager->CreatePhysicalEntitys();
}
ResetParticlesAndDecals( );
}
void C3DEngine::CheckPhysicalized(const Vec3d & vBoxMin, const Vec3d & vBoxMax)
{
if(!GetCVars()->e_stream_areas)
return;
CVisArea * pVisArea = (CVisArea *)GetVisAreaFromPos((vBoxMin+vBoxMax)*0.5f);
if(pVisArea)
{ // indoor
pVisArea->CheckPhysicalized();
IVisArea * arrConnections[16];
int nConections = pVisArea->GetRealConnections(arrConnections,16);
for(int i=0; i<nConections; i++)
((CVisArea*)arrConnections[i])->CheckPhysicalized();
}
else
{ // outdoor
CSectorInfo * arrSecInfo[] =
{
m_pTerrain->GetSecInfo(int(vBoxMin.x), int(vBoxMin.y)),
m_pTerrain->GetSecInfo(int(vBoxMax.x), int(vBoxMin.y)),
m_pTerrain->GetSecInfo(int(vBoxMin.x), int(vBoxMax.y)),
m_pTerrain->GetSecInfo(int(vBoxMax.x), int(vBoxMax.y))
};
for(int i=0; i<4; i++)
if(arrSecInfo[i])
arrSecInfo[i]->CheckPhysicalized();
}
}
void C3DEngine::CheckMemoryHeap()
{
assert (IsHeapValid());
}
void C3DEngine::RecompileBeaches()
{
if(m_pTerrain)
m_pTerrain->InitBeaches(true);
}
float C3DEngine::GetObjectsLODRatio()
{
return GetCVars()->e_obj_lod_ratio;
}
float C3DEngine::GetObjectsViewDistRatio()
{
return GetCVars()->e_obj_view_dist_ratio;
}
float C3DEngine::GetObjectsMinViewDist()
{
return GetCVars()->e_obj_min_view_dist;
}
bool C3DEngine::SetMaterialFloat( char * szMatName, int nSubMatId, int nTexSlot, char * szParamName, float fValue )
{
IMatInfo * pMatInfo = FindMaterial( szMatName );
if(!pMatInfo)
{ Warning(0,0,"I3DEngine::SetMaterialFloat: Material not found: %s", szMatName); return false; }
if(nSubMatId>0)
{
if(nSubMatId<=pMatInfo->GetSubMtlCount())
pMatInfo = pMatInfo->GetSubMtl(nSubMatId-1);
else
{
Warning(0,0,"I3DEngine::SetMaterialFloat: SubMaterial not found: %s, SubMatId: %d", szMatName, nSubMatId);
return false;
}
}
SEfResTexture * pTex = pMatInfo->GetShaderItem().m_pShaderResources->m_Textures[nTexSlot];
if(!pTex)
{ Warning(0,0,"I3DEngine::SetMaterialFloat: Texture slot not found: %s, TexSlot: %d", szMatName, nTexSlot); return false; }
char szM_Name[128] = "";
if(strncmp(szParamName,"m_", 2))
strncpy(szM_Name,"m_",sizeof(szM_Name));
strncat(szM_Name,szParamName,sizeof(szM_Name));
return pTex->m_TexModificator.SetMember(szM_Name,fValue);
}
void C3DEngine::CloseTerrainTextureFile()
{
if(m_pTerrain)
m_pTerrain->CloseTerrainTextureFile();
}
//////////////////////////////////////////////////////////////////////////
IParticleEffect* C3DEngine::CreateParticleEffect()
{
if (m_pPartManager)
return m_pPartManager->CreateEffect();
return 0;
}
//////////////////////////////////////////////////////////////////////////
void C3DEngine::DeleteParticleEffect( IParticleEffect* pEffect )
{
if (m_pPartManager)
m_pPartManager->RemoveEffect( pEffect );
}
//////////////////////////////////////////////////////////////////////////
IParticleEffect* C3DEngine::FindParticleEffect( const char *sEffectName )
{
if (m_pPartManager)
return m_pPartManager->FindEffect( sEffectName );
return 0;
}
int C3DEngine::GetLoadedObjectCount()
{
int nObjectsLoaded = m_pObjManager ? m_pObjManager->GetLoadedObjectCount() : 0;
if(GetSystem()->GetIAnimationSystem())
{
ICryCharManager::Statistics AnimStats;
GetSystem()->GetIAnimationSystem()->GetStatistics(AnimStats);
nObjectsLoaded += AnimStats.numAnimObjectModels + AnimStats.numCharModels;
}
return nObjectsLoaded;
}
void C3DEngine::DeleteEntityDecals(IEntityRender * pEntity)
{
if(m_pDecalManager && pEntity)
m_pDecalManager->OnEntityDeleted(pEntity);
}
void C3DEngine::OnLevelLoaded()
{
if(GetCVars()->e_precache_level)
{
UpdateLoadingScreen("\003Precaching level ... ");
/*
CCamera cam = GetViewCamera();
cam.SetPos(Vec3d(0,0,16));
cam.SetAngle(Vec3d(0,0,-90));
Get3DEngine()->SetCamera(cam);
GetRenderer()->BeginFrame();*/
if(m_pObjManager && m_pVisAreaManager)
m_pVisAreaManager->Preceche(m_pObjManager);
//GetRenderer()->Update();
UpdateLoadingScreenPlus("\003done");
}
/*
for(int x=0; x<C3DEngine::GetTerrainSize(); x+=GetTerrainSectorSize())
for(int y=0; y<C3DEngine::GetTerrainSize(); y+=GetTerrainSectorSize())
{
int nPosStride=0, nVertCount=0;
const char * pVerts = (const char *)C3DEngine::GetShoreGeometry(nPosStride, nVertCount, x, y);
for(int v=0 ;v<nVertCount && pVerts; v++)
{
Vec3d vPos = *((Vec3d*)&pVerts[nPosStride*v]);
assert(pVerts);
}
}*/
}
void C3DEngine::DeleteDecalsInRange( Vec3d vBoxMin, Vec3d vBoxMax, bool bDeleteBigTerrainDecals)
{
if(m_pDecalManager)
m_pDecalManager->DeleteDecalsInRange(vBoxMin, vBoxMax, bDeleteBigTerrainDecals);
}
const void * C3DEngine::GetShoreGeometry(int & nPosStride, int & nVertCount, int nSectorX, int nSectorY)
{
if(!this || !m_pTerrain)
return 0;
return m_pTerrain->GetShoreGeometry(nPosStride, nVertCount, nSectorX, nSectorY);
}
void C3DEngine::LockCGFResources()
{
if(m_pObjManager)
m_pObjManager->m_bLockCGFResources = true;
}
void C3DEngine::UnlockCGFResources()
{
if(m_pObjManager)
{
m_pObjManager->m_bLockCGFResources = false;
m_pObjManager->FreeNotUsedCGFs();
}
}
void IEntityRenderState::ShadowMapInfo::Release(enum EERType eEntType, struct IRenderer * pRenderer)
{
if(pShadowMapCasters)
{
pShadowMapCasters->Clear();
delete pShadowMapCasters;
pShadowMapCasters = 0;
}
if( pShadowMapFrustumContainer && eEntType != eERType_Vegetation ) // vegetations share same frustum allocated in CStatObj
{
delete pShadowMapFrustumContainer->m_LightFrustums.Get(0)->pEntityList;
pShadowMapFrustumContainer->m_LightFrustums.Get(0)->pEntityList=0;
delete pShadowMapFrustumContainer->m_LightFrustums.Get(0)->pModelsList;
pShadowMapFrustumContainer->m_LightFrustums.Get(0)->pModelsList=0;
delete pShadowMapFrustumContainer;
pShadowMapFrustumContainer=0;
}
if( pShadowMapFrustumContainerPassiveCasters && eEntType != eERType_Vegetation ) // vegetations share same frustum allocated in CStatObj
{
delete pShadowMapFrustumContainerPassiveCasters->m_LightFrustums.Get(0)->pEntityList;
pShadowMapFrustumContainerPassiveCasters->m_LightFrustums.Get(0)->pEntityList=0;
delete pShadowMapFrustumContainerPassiveCasters->m_LightFrustums.Get(0)->pModelsList;
pShadowMapFrustumContainerPassiveCasters->m_LightFrustums.Get(0)->pModelsList=0;
delete pShadowMapFrustumContainerPassiveCasters;
pShadowMapFrustumContainerPassiveCasters=0;
}
if(pShadowMapLeafBuffersList)
{
for(int i=0; i<pShadowMapLeafBuffersList->Count(); i++)
{
if(pShadowMapLeafBuffersList->GetAt(i))
{
pRenderer->DeleteLeafBuffer(pShadowMapLeafBuffersList->GetAt(i));
pShadowMapLeafBuffersList->GetAt(i)=0;
}
}
delete pShadowMapLeafBuffersList;
pShadowMapLeafBuffersList=0;
}
delete this;
}
Reference in New Issue View Git Blame Copy Permalink