void Startup(LPSTR lpCmdLine)
{
char cmd[512],name[256];
BOOL bModifyOptions = FALSE;
strcpy(cmd,lpCmdLine);
strlwr(cmd);
if (strstr(cmd,"-?") || strstr(cmd,"-h")) { Help(); return; }
if (strstr(cmd,"-f")==0) { Help(); return; }
if (strstr(cmd,"-o")) bModifyOptions = TRUE;
// Give a LOG-thread a chance to startup
InitCommonControls ();
thread_spawn (logThread, "log-update", 1024*1024,0);
Sleep (150);
// Load project
name[0]=0; sscanf (strstr(cmd,"-f")+2,"%s",name);
//FS.update_path (name,"$game_levels$",name);
FS.get_path ("$level$")->_set (name);
CTimer dwStartupTime; dwStartupTime.Start();
xrCompiler (0);
// Show statistic
char stats[256];
extern std::string make_time(u32 sec);
extern HWND logWindow;
sprintf (stats,"Time elapsed: %s",make_time((dwStartupTime.GetElapsed_ms())/1000).c_str());
MessageBox (logWindow,stats,"Congratulation!",MB_OK|MB_ICONINFORMATION);
bClose = TRUE;
Sleep (500);
}
void CEditorRenderDevice::Reset(IReader* F, BOOL bKeepTextures)
{
CTimer tm;
tm.Start();
_Destroy (bKeepTextures);
_Create (F);
Msg ("*** RESET [%d ms]",tm.GetElapsed_ms());
}
void CTextureDescrMngr::Load()
{
CTimer TT;
TT.Start ();
LoadLTX ();
LoadTHM ();
Msg("load time=%d ms",TT.GetElapsed_ms());
}
void CUITextureMaster::InitTexture(const char* texture_name, const char* shader_name, IUISimpleTextureControl* tc){
#ifdef DEBUG
CTimer T;
T.Start();
#endif
xr_map<shared_str, TEX_INFO>::iterator it;
it = m_textures.find(texture_name);
if (it != m_textures.end())
{
tc->CreateShader(*((*it).second.file), shader_name);
tc->SetOriginalRectEx((*it).second.rect);
#ifdef DEBUG
m_time += T.GetElapsed_ms();
#endif
return;
}
tc->CreateShader(texture_name, shader_name);
#ifdef DEBUG
m_time += T.GetElapsed_ms();
#endif
}
void CBuild::mem_CompactSubdivs()
{
// Memory compact
CTimer dwT; dwT.Start();
vecFace temp;
for (int SP = 0; SP<int(g_XSplit.size()); SP++)
{
temp.clear ();
temp.assign (g_XSplit[SP]->begin(),g_XSplit[SP]->end());
xr_delete (g_XSplit[SP]);
mem_Compact ();
g_XSplit[SP] = xr_new<vecFace> ();
g_XSplit[SP]->assign(temp.begin(),temp.end());
}
clMsg ("%d ms for memory compacting...",dwT.GetElapsed_ms());
}
u32 R_occlusion::occq_get (u32& ID )
{
if (!enabled) return 0xffffffff;
DWORD fragments = 0;
HRESULT hr;
// CHK_DX (used[ID].Q->GetData(&fragments,sizeof(fragments),D3DGETDATA_FLUSH));
// Msg ("get : [%2d] - %d => %d", used[ID].order, ID, fragments);
CTimer T;
T.Start ();
Device.Statistic->RenderDUMP_Wait.Begin ();
while ((hr=used[ID].Q->GetData(&fragments,sizeof(fragments),D3DGETDATA_FLUSH))==S_FALSE) {
if (!SwitchToThread()) Sleep(ps_r2_wait_sleep);
if (T.GetElapsed_ms() > 500) {
fragments = 0xffffffff;
break;
}
}
Device.Statistic->RenderDUMP_Wait.End ();
if (hr == D3DERR_DEVICELOST) fragments = 0xffffffff;
if (0==fragments) RImplementation.stats.o_culled ++;
// insert into pool (sorting in decreasing order)
_Q& Q = used[ID];
if (pool.empty()) pool.push_back(Q);
else {
int it = int(pool.size())-1;
while ((it>=0) && (pool[it].order < Q.order)) it--;
pool.insert (pool.begin()+it+1,Q);
}
// remove from used and shrink as nescessary
used[ID].Q = 0;
fids.push_back (ID);
ID = 0;
return fragments;
}
void Startup(LPSTR lpCmdLine)
{
char cmd[512],name[256];
BOOL bModifyOptions = FALSE;
strcpy(cmd,lpCmdLine);
strlwr(cmd);
if (strstr(cmd,"-?") || strstr(cmd,"-h")) { Help(); return; }
if (strstr(cmd,"-f")==0) { Help(); return; }
if (strstr(cmd,"-o")) bModifyOptions = TRUE;
if (strstr(cmd,"-gi")) b_radiosity = TRUE;
if (strstr(cmd,"-noise")) b_noise = TRUE;
if (strstr(cmd,"-nosun")) b_nosun = TRUE;
// Give a LOG-thread a chance to startup
//_set_sbh_threshold(1920);
InitCommonControls ();
thread_spawn (logThread, "log-update", 1024*1024,0);
Sleep (150);
// Faster FPU
SetPriorityClass (GetCurrentProcess(),NORMAL_PRIORITY_CLASS);
/*
u32 dwMin = 1800*(1024*1024);
u32 dwMax = 1900*(1024*1024);
if (0==SetProcessWorkingSetSize(GetCurrentProcess(),dwMin,dwMax))
{
clMsg("*** Failed to expand working set");
};
*/
// Load project
name[0]=0; sscanf(strstr(cmd,"-f")+2,"%s",name);
string256 prjName;
FS.update_path (prjName,"$game_levels$",strconcat(prjName,name,"\\build.prj"));
string256 phaseName;
Phase (strconcat(phaseName,"Reading project [",name,"]..."));
string256 inf;
extern HWND logWindow;
IReader* F = FS.r_open(prjName);
if (NULL==F){
sprintf (inf,"Build failed!\nCan't find level: '%s'",name);
clMsg (inf);
MessageBox (logWindow,inf,"Error!",MB_OK|MB_ICONERROR);
return;
}
// Version
u32 version;
F->r_chunk (EB_Version,&version);
clMsg ("version: %d",version);
R_ASSERT(XRCL_CURRENT_VERSION==version);
// Header
b_params Params;
F->r_chunk (EB_Parameters,&Params);
// Show options if needed
if (bModifyOptions)
{
Phase ("Project options...");
HMODULE L = LoadLibrary ("xrLC_Options.dll");
void* P = GetProcAddress (L,"_frmScenePropertiesRun");
R_ASSERT (P);
xrOptions* O = (xrOptions*)P;
int R = O(&Params,version,false);
FreeLibrary (L);
if (R==2) {
ExitProcess(0);
}
}
// Conversion
Phase ("Converting data structures...");
pBuild = xr_new<CBuild>();
pBuild->Load (Params,*F);
xr_delete (F);
// Call for builder
string256 lfn;
CTimer dwStartupTime; dwStartupTime.Start();
FS.update_path (lfn,_game_levels_,name);
pBuild->Run (lfn);
xr_delete (pBuild);
// Show statistic
extern std::string make_time(u32 sec);
u32 dwEndTime = dwStartupTime.GetElapsed_ms();
sprintf (inf,"Time elapsed: %s",make_time(dwEndTime/1000).c_str());
clMsg ("Build succesful!\n%s",inf);
MessageBox (logWindow,inf,"Congratulation!",MB_OK|MB_ICONINFORMATION);
// Close log
bClose = TRUE;
Sleep (500);
}
void CRender::Render ()
{
g_r = 1;
VERIFY (0==mapDistort.size());
bool _menu_pp = g_pGamePersistent?g_pGamePersistent->OnRenderPPUI_query():false;
if (_menu_pp) {
render_menu () ;
return ;
};
if( !(g_pGameLevel && g_pGameLevel->pHUD) ) return;
//. VERIFY (g_pGameLevel && g_pGameLevel->pHUD);
// Configure
RImplementation.o.distortion = FALSE; // disable distorion
Fcolor sun_color = ((light*)Lights.sun_adapted._get())->color;
BOOL bSUN = ps_r2_ls_flags.test(R2FLAG_SUN) && (u_diffuse2s(sun_color.r,sun_color.g,sun_color.b)>EPS);
if (o.sunstatic) bSUN = FALSE;
// Msg ("sstatic: %s, sun: %s",o.sunstatic?"true":"false", bSUN?"true":"false");
// HOM
ViewBase.CreateFromMatrix (Device.mFullTransform, FRUSTUM_P_LRTB + FRUSTUM_P_FAR);
View = 0;
if (!ps_r2_ls_flags.test(R2FLAG_EXP_MT_CALC)) {
HOM.Enable ();
HOM.Render (ViewBase);
}
//******* Z-prefill calc - DEFERRER RENDERER
if (ps_r2_ls_flags.test(R2FLAG_ZFILL)) {
Device.Statistic->RenderCALC.Begin ();
float z_distance = ps_r2_zfill ;
Fmatrix m_zfill, m_project ;
m_project.build_projection (
deg2rad(Device.fFOV/* *Device.fASPECT*/),
Device.fASPECT, VIEWPORT_NEAR,
z_distance * g_pGamePersistent->Environment().CurrentEnv.far_plane);
m_zfill.mul (m_project,Device.mView);
r_pmask (true,false); // enable priority "0"
set_Recorder (NULL) ;
phase = PHASE_SMAP;
render_main (m_zfill,false) ;
r_pmask (true,false); // disable priority "1"
Device.Statistic->RenderCALC.End ( ) ;
// flush
Target->phase_scene_prepare ();
RCache.set_ColorWriteEnable (FALSE);
r_dsgraph_render_graph (0);
RCache.set_ColorWriteEnable ( );
} else {
Target->phase_scene_prepare ();
}
//*******
// Sync point
Device.Statistic->RenderDUMP_Wait_S.Begin ();
if (1)
{
CTimer T; T.Start ();
BOOL result = FALSE;
HRESULT hr = S_FALSE;
while ((hr=q_sync_point[q_sync_count]->GetData (&result,sizeof(result),D3DGETDATA_FLUSH))==S_FALSE) {
if (!SwitchToThread()) Sleep(ps_r2_wait_sleep);
if (T.GetElapsed_ms() > 500) {
result = FALSE;
break;
}
}
}
Device.Statistic->RenderDUMP_Wait_S.End ();
q_sync_count = (q_sync_count+1)%2;
CHK_DX (q_sync_point[q_sync_count]->Issue(D3DISSUE_END));
//******* Main calc - DEFERRER RENDERER
// Main calc
Device.Statistic->RenderCALC.Begin ();
r_pmask (true,false,true); // enable priority "0",+ capture wmarks
if (bSUN) set_Recorder (&main_coarse_structure);
else set_Recorder (NULL);
phase = PHASE_NORMAL;
render_main (Device.mFullTransform,true);
set_Recorder (NULL);
r_pmask (true,false); // disable priority "1"
Device.Statistic->RenderCALC.End ();
BOOL split_the_scene_to_minimize_wait = FALSE;
if (ps_r2_ls_flags.test(R2FLAG_EXP_SPLIT_SCENE)) split_the_scene_to_minimize_wait=TRUE;
//******* Main render :: PART-0 -- first
if (!split_the_scene_to_minimize_wait)
{
// level, DO NOT SPLIT
Target->phase_scene_begin ();
r_dsgraph_render_hud ();
r_dsgraph_render_graph (0);
r_dsgraph_render_lods (true,true);
if(Details) Details->Render ();
Target->phase_scene_end ();
} else {
// level, SPLIT
Target->phase_scene_begin ();
r_dsgraph_render_graph (0);
Target->disable_aniso ();
}
//******* Occlusion testing of volume-limited light-sources
Target->phase_occq ();
LP_normal.clear ();
LP_pending.clear ();
{
// perform tests
u32 count = 0;
light_Package& LP = Lights.package;
// stats
stats.l_shadowed = LP.v_shadowed.size();
stats.l_unshadowed = LP.v_point.size() + LP.v_spot.size();
stats.l_total = stats.l_shadowed + stats.l_unshadowed;
// perform tests
count = _max (count,LP.v_point.size());
count = _max (count,LP.v_spot.size());
count = _max (count,LP.v_shadowed.size());
for (u32 it=0; it<count; it++) {
if (it<LP.v_point.size()) {
light* L = LP.v_point [it];
L->vis_prepare ();
if (L->vis.pending) LP_pending.v_point.push_back (L);
else LP_normal.v_point.push_back (L);
}
if (it<LP.v_spot.size()) {
light* L = LP.v_spot [it];
L->vis_prepare ();
if (L->vis.pending) LP_pending.v_spot.push_back (L);
else LP_normal.v_spot.push_back (L);
}
if (it<LP.v_shadowed.size()) {
light* L = LP.v_shadowed [it];
L->vis_prepare ();
if (L->vis.pending) LP_pending.v_shadowed.push_back (L);
else LP_normal.v_shadowed.push_back (L);
}
}
}
LP_normal.sort ();
LP_pending.sort ();
//******* Main render :: PART-1 (second)
if (split_the_scene_to_minimize_wait) {
// skybox can be drawn here
if (0)
{
Target->u_setrt ( Target->rt_Generic_0, Target->rt_Generic_1,0,HW.pBaseZB );
RCache.set_CullMode ( CULL_NONE );
RCache.set_Stencil ( FALSE );
// draw skybox
RCache.set_ColorWriteEnable ();
CHK_DX(HW.pDevice->SetRenderState ( D3DRS_ZENABLE, FALSE ));
g_pGamePersistent->Environment().RenderSky ();
CHK_DX(HW.pDevice->SetRenderState ( D3DRS_ZENABLE, TRUE ));
}
// level
Target->phase_scene_begin ();
r_dsgraph_render_hud ();
r_dsgraph_render_lods (true,true);
if(Details) Details->Render ();
Target->phase_scene_end ();
}
// Wall marks
if(Wallmarks) {
Target->phase_wallmarks ();
if (!ps_common_flags.test(RFLAG_BLOODMARKS)) g_r = 0;
Wallmarks->Render (); // wallmarks has priority as normal geometry
}
// Update incremental shadowmap-visibility solver
{
u32 it=0;
for (it=0; it<Lights_LastFrame.size(); it++) {
if (0==Lights_LastFrame[it]) continue ;
try {
Lights_LastFrame[it]->svis.flushoccq() ;
} catch (...)
{
Msg ("! Failed to flush-OCCq on light [%d] %X",it,*(u32*)(&Lights_LastFrame[it]));
}
}
Lights_LastFrame.clear ();
}
// Directional light - f*****g sun
if (bSUN) {
RImplementation.stats.l_visible ++;
render_sun_near ();
render_sun ();
render_sun_filtered ();
Target->accum_direct_blend ();
}
// Lighting, non dependant on OCCQ
Target->phase_accumulator ();
HOM.Disable ();
render_lights (LP_normal);
// Lighting, dependant on OCCQ
render_lights (LP_pending);
// Postprocess
Target->phase_combine ();
VERIFY (0==mapDistort.size());
}
