void TClipMaker::LoadClips()
{
bool bRes=true;
if (EFS.GetOpenName("$clips$",m_ClipFName)){
Clear ();
IReader* F = FS.r_open(m_ClipFName.c_str()); VERIFY(F);
m_ClipFName = EFS.ExcludeBasePath(m_ClipFName.c_str(),FS.get_path("$clips$")->m_Path);
if (F->find_chunk(CHUNK_ZOOM)){
m_Zoom = F->r_float();
}
IReader* C = F->open_chunk(CHUNK_CLIPS);
if(C){
IReader* M = C->open_chunk(0);
for (int count=1; M; count++) {
CUIClip* clip = xr_new<CUIClip>(this,count);
if (!clip->Load(*M)){
ELog.Msg(mtError,"Unsupported clip version. Load failed.");
xr_delete(clip);
bRes = false;
}
M->close();
if (!bRes) break;
clips.push_back(clip);
M = C->open_chunk(count);
}
C->close ();
UpdateClips ();
}
FS.r_close(F);
}
}
void ELightAnimLibrary::Load()
{
string_path fn;
FS.update_path(fn,_game_data_,"lanims.xr");
IReader* fs=FS.r_open(fn);
if (fs){
u16 version = 0;
if (fs->find_chunk(CHUNK_VERSION)){
version = fs->r_u16();
}
IReader* OBJ = fs->open_chunk(CHUNK_ITEM_LIST);
if (OBJ){
IReader* O = OBJ->open_chunk(0);
for (int count=1; O; count++) {
CLAItem* I = xr_new<CLAItem>();
I->Load(*O);
if (version==0){
for (CLAItem::KeyPairIt it=I->Keys.begin(); it!=I->Keys.end(); it++)
it->second = subst_alpha(bgr2rgb(it->second),color_get_A(it->second));
}
Items.push_back(I);
O->close();
O = OBJ->open_chunk(count);
}
OBJ->close();
}
FS.r_close(fs);
}
}
void CALifeSpawnRegistry::load (IReader &file_stream, xrGUID *save_guid)
{
IReader *chunk;
chunk = file_stream.open_chunk(0);
m_header.load (*chunk);
chunk->close ();
R_ASSERT2 (!save_guid || (*save_guid == header().guid()) || ignore_save_incompatibility(),"Saved game doesn't correspond to the spawn : DELETE SAVED GAME!");
chunk = file_stream.open_chunk(1);
m_spawns.load (*chunk);
chunk->close ();
#if 0
SPAWN_GRAPH::vertex_iterator I = m_spawns.vertices().begin();
SPAWN_GRAPH::vertex_iterator E = m_spawns.vertices().end();
for ( ; I != E; ++I) {
luabind::wrap_base *base = smart_cast<luabind::wrap_base*>(&(*I).second->data()->object());
if (!base)
continue;
if (xr_strcmp((*I).second->data()->object().name_replace(),"rostok_stalker_outfit"))
continue;
dummy *_dummy = (dummy*)((void*)base->m_self.m_impl);
lua_State **_state = &_dummy->state;
Msg ("0x%08x",*(int*)&_state);
break;
}
#endif
chunk = file_stream.open_chunk(2);
load_data (m_artefact_spawn_positions,*chunk);
chunk->close ();
chunk = file_stream.open_chunk(3);
R_ASSERT2 (chunk,"Spawn version mismatch - REBUILD SPAWN!");
ai().patrol_path_storage (*chunk);
chunk->close ();
VERIFY (!m_chunk);
m_chunk = file_stream.open_chunk(4);
R_ASSERT2 (m_chunk,"Spawn version mismatch - REBUILD SPAWN!");
VERIFY (!m_game_graph);
m_game_graph = new CGameGraph(*m_chunk);
ai().game_graph (m_game_graph);
R_ASSERT2 ((header().graph_guid() == ai().game_graph().header().guid()) || ignore_save_incompatibility(),"Spawn doesn't correspond to the graph : REBUILD SPAWN!");
build_story_spawns ();
build_root_spawns ();
Msg ("* %d spawn points are successfully loaded",m_spawns.vertex_count());
}
void CPatrolPathStorage::load_raw (const CLevelGraph *level_graph, const CGameLevelCrossTable *cross, const CGameGraph *game_graph, IReader &stream)
{
IReader *chunk = stream.open_chunk(WAY_PATROLPATH_CHUNK);
if (!chunk)
return;
u32 chunk_iterator;
for (IReader *sub_chunk = chunk->open_chunk_iterator(chunk_iterator); sub_chunk; sub_chunk = chunk->open_chunk_iterator(chunk_iterator,sub_chunk)) {
R_ASSERT (sub_chunk->find_chunk(WAYOBJECT_CHUNK_VERSION));
R_ASSERT (sub_chunk->r_u16() == WAYOBJECT_VERSION);
R_ASSERT (sub_chunk->find_chunk(WAYOBJECT_CHUNK_NAME));
shared_str patrol_name;
sub_chunk->r_stringZ (patrol_name);
const_iterator I = m_registry.find(patrol_name);
VERIFY3 (I == m_registry.end(),"Duplicated patrol path found",*patrol_name);
m_registry.insert (
std::make_pair(
patrol_name,
&xr_new<CPatrolPath>(
patrol_name
)->load_raw(
level_graph,
cross,
game_graph,
*sub_chunk
)
)
);
}
chunk->close ();
}
bool ESceneLightTools::Load(IReader& F)
{
u16 version = 0;
if(F.r_chunk(CHUNK_VERSION,&version))
if( version!=LIGHT_TOOLS_VERSION ){
ELog.DlgMsg( mtError, "%s tools: Unsupported version.",ClassDesc());
return false;
}
if (!inherited::Load(F)) return false;
if (F.find_chunk(CHUNK_FLAGS))
m_Flags.assign (F.r_u32());
if (F.find_chunk(CHUNK_SUN_SHADOW)){
F.r_u8 ();
F.r_fvector2 (m_SunShadowDir);
}
if (F.find_chunk(CHUNK_LCONTROLS_LAST))
lcontrol_last_idx = F.r_u32();
IReader* R = F.open_chunk(CHUNK_LCONTROLS);
if (R){
while (!R->eof()){
shared_str l_name;
R->r_stringZ(l_name);
u32 l_idx = R->r_u32();
AppendLightControl(l_name.c_str(),&l_idx);
}
R->close ();
}
return true;
}
/*
void dump (CDetailManager::vis_list& lst)
{
for (int i=0; i<lst.size(); i++)
{
Msg("%8x / %8x / %8x", lst[i]._M_start, lst[i]._M_finish, lst[i]._M_end_of_storage._M_data);
}
}
*/
void CDetailManager::Load ()
{
// Open file stream
if (!FS.exist("$level$","level.details"))
{
dtFS = NULL;
return;
}
string256 fn;
FS.update_path (fn,"$level$","level.details");
dtFS = FS.r_open(fn);
// Header
dtFS->r_chunk_safe (0,&dtH,sizeof(dtH));
R_ASSERT (dtH.version == DETAIL_VERSION);
u32 m_count = dtH.object_count;
// Models
IReader* m_fs = dtFS->open_chunk(1);
for (u32 m_id = 0; m_id < m_count; m_id++)
{
CDetail* dt = xr_new<CDetail> ();
IReader* S = m_fs->open_chunk(m_id);
dt->Load (S);
objects.push_back (dt);
S->close ();
}
m_fs->close ();
// Get pointer to database (slots)
IReader* m_slots = dtFS->open_chunk(2);
dtSlots = (DetailSlot*)m_slots->pointer();
m_slots->close ();
// Initialize 'vis' and 'cache'
for (u32 i=0; i<3; ++i) visible[i].resize(objects.size());
cache_Initialize ();
// Make dither matrix
bwdithermap (2,dither);
// Hardware specific optimizations
if (UseVS()) hw_Load ();
else soft_Load ();
// swing desc
// normal
swing_desc[0].amp1 = pSettings->r_float("details","swing_normal_amp1");
swing_desc[0].amp2 = pSettings->r_float("details","swing_normal_amp2");
swing_desc[0].rot1 = pSettings->r_float("details","swing_normal_rot1");
swing_desc[0].rot2 = pSettings->r_float("details","swing_normal_rot2");
swing_desc[0].speed = pSettings->r_float("details","swing_normal_speed");
// fast
swing_desc[1].amp1 = pSettings->r_float("details","swing_fast_amp1");
swing_desc[1].amp2 = pSettings->r_float("details","swing_fast_amp2");
swing_desc[1].rot1 = pSettings->r_float("details","swing_fast_rot1");
swing_desc[1].rot2 = pSettings->r_float("details","swing_fast_rot2");
swing_desc[1].speed = pSettings->r_float("details","swing_fast_speed");
}
void FHierrarhyVisual::Load(const char* N, IReader *data, u32 dwFlags)
{
dxRender_Visual::Load(N,data,dwFlags);
if (data->find_chunk(OGF_CHILDREN_L))
{
// From Link
u32 cnt = data->r_u32 ();
children.resize (cnt);
for (u32 i=0; i<cnt; i++) {
#ifdef _EDITOR
THROW;
#else
u32 ID = data->r_u32();
children[i] = (dxRender_Visual*)::Render->getVisual(ID);
#endif
}
bDontDelete = TRUE;
}
else
{
if (data->find_chunk(OGF_CHILDREN))
{
// From stream
IReader* OBJ = data->open_chunk(OGF_CHILDREN);
if (OBJ){
IReader* O = OBJ->open_chunk(0);
for (int count=1; O; count++) {
string_path name_load,short_name,num;
xr_strcpy (short_name,N);
if (strext(short_name)) *strext(short_name)=0;
strconcat (sizeof(name_load),name_load,short_name,":",itoa(count,num,10));
children.push_back ((dxRender_Visual*)::Render->model_CreateChild(name_load,O));
O->close ();
O = OBJ->open_chunk (count);
}
OBJ->close();
}
bDontDelete = FALSE;
}
else
{
FATAL ("Invalid visual");
}
}
}
bool CPSLibrary::Load(const char* nm)
{
IReader* F = FS.r_open(nm);
bool bRes = true;
R_ASSERT(F->find_chunk(PS_CHUNK_VERSION));
u16 ver = F->r_u16();
if (ver!=PS_VERSION) return false;
// second generation
IReader* OBJ;
OBJ = F->open_chunk(PS_CHUNK_SECONDGEN);
if (OBJ){
IReader* O = OBJ->open_chunk(0);
for (int count=1; O; count++) {
PS::CPEDef* def = xr_new<PS::CPEDef>();
if (def->Load(*O)) m_PEDs.push_back(def);
else{ bRes = false; xr_delete(def); }
O->close();
if (!bRes) break;
O = OBJ->open_chunk(count);
}
OBJ->close();
}
// second generation
OBJ = F->open_chunk(PS_CHUNK_THIRDGEN);
if (OBJ){
IReader* O = OBJ->open_chunk(0);
for (int count=1; O; count++) {
PS::CPGDef* def = xr_new<PS::CPGDef>();
if (def->Load(*O)) m_PGDs.push_back(def);
else{ bRes = false; xr_delete(def); }
O->close();
if (!bRes) break;
O = OBJ->open_chunk(count);
}
OBJ->close();
}
// final
FS.r_close (F);
std::sort (m_PEDs.begin(),m_PEDs.end(),ped_sort_pred);
std::sort (m_PGDs.begin(),m_PGDs.end(),pgd_sort_pred);
return bRes;
}
void CHOM::Load ()
{
// Find and open file
string_path fName;
FS.update_path (fName,"$level$","level.hom");
if (!FS.exist(fName))
{
Msg (" WARNING: Occlusion map '%s' not found.",fName);
return;
}
Msg ("* Loading HOM: %s",fName);
IReader* fs = FS.r_open(fName);
IReader* S = fs->open_chunk(1);
// Load tris and merge them
CDB::Collector CL;
while (!S->eof())
{
HOM_poly P;
S->r (&P,sizeof(P));
CL.add_face_packed_D (P.v1,P.v2,P.v3,P.flags,0.01f);
}
// Determine adjacency
xr_vector<u32> adjacency;
CL.calc_adjacency (adjacency);
// Create RASTER-triangles
m_pTris = xr_alloc<occTri> (u32(CL.getTS()));
for (u32 it=0; it<CL.getTS(); it++)
{
CDB::TRI& clT = CL.getT()[it];
occTri& rT = m_pTris[it];
Fvector& v0 = CL.getV()[clT.verts[0]];
Fvector& v1 = CL.getV()[clT.verts[1]];
Fvector& v2 = CL.getV()[clT.verts[2]];
rT.adjacent[0] = (0xffffffff==adjacency[3*it+0])?((occTri*) (-1)):(m_pTris+adjacency[3*it+0]);
rT.adjacent[1] = (0xffffffff==adjacency[3*it+1])?((occTri*) (-1)):(m_pTris+adjacency[3*it+1]);
rT.adjacent[2] = (0xffffffff==adjacency[3*it+2])?((occTri*) (-1)):(m_pTris+adjacency[3*it+2]);
rT.flags = clT.dummy;
rT.area = Area (v0,v1,v2);
if (rT.area<EPS_L) {
Msg ("! Invalid HOM triangle (%f,%f,%f)-(%f,%f,%f)-(%f,%f,%f)",VPUSH(v0),VPUSH(v1),VPUSH(v2));
}
rT.plane.build (v0,v1,v2);
rT.skip = 0;
rT.center.add(v0,v1).add(v2).div(3.f);
}
// Create AABB-tree
m_pModel = xr_new<CDB::MODEL> ();
m_pModel->build (CL.getV(),int(CL.getVS()),CL.getT(),int(CL.getTS()));
bEnabled = TRUE;
S->close ();
FS.r_close (fs);
}
void transfer(const char *name, xr_vector<T> &dest, IReader& F, u32 chunk)
{
IReader* O = F.open_chunk(chunk);
u32 count = O?(O->length()/sizeof(T)):0;
clMsg ("* %16s: %d",name,count);
if (count)
{
dest.reserve(count);
dest.insert (dest.begin(), (T*)O->pointer(), (T*)O->pointer() + count);
}
if (O) O->close ();
}
void CPatrolPathStorage::load (IReader &stream)
{
IReader *chunk;
chunk = stream.open_chunk(0);
u32 size = chunk->r_u32();
chunk->close ();
m_registry.clear ();
PATROL_REGISTRY::value_type pair;
chunk = stream.open_chunk(1);
for (u32 i=0; i<size; ++i) {
IReader *chunk1;
chunk1 = chunk->open_chunk(i);
IReader *chunk2;
chunk2 = chunk1->open_chunk(0);
load_data (pair.first,*chunk2);
chunk2->close ();
chunk2 = chunk1->open_chunk(1);
load_data (pair.second,*chunk2);
chunk2->close ();
chunk1->close ();
const_iterator I = m_registry.find(pair.first);
VERIFY3 (I == m_registry.end(),"Duplicated patrol path found ",*pair.first);
#ifdef DEBUG
pair.second->name (pair.first);
#endif
m_registry.insert (pair);
}
chunk->close ();
}
bool EDetailManager::LoadColorIndices(IReader& F)
{
VERIFY (objects.empty());
VERIFY (m_ColorIndices.empty());
bool bRes = true;
// objects
IReader* OBJ = F.open_chunk(DETMGR_CHUNK_OBJECTS);
if (OBJ){
IReader* O = OBJ->open_chunk(0);
for (int count=1; O; count++) {
EDetail* DO = xr_new<EDetail>();
if (DO->Load(*O)) objects.push_back(DO);
else bRes = false;
O->close();
O = OBJ->open_chunk(count);
}
OBJ->close();
}
// color index map
R_ASSERT (F.find_chunk(DETMGR_CHUNK_COLOR_INDEX));
int cnt = F.r_u8();
string256 buf;
u32 index;
int ref_cnt;
for (int k=0; k<cnt; k++){
index = F.r_u32();
ref_cnt = F.r_u8();
for (int j=0; j<ref_cnt; j++){
F.r_stringZ (buf,sizeof(buf));
EDetail* DO = FindDOByName(buf);
if (DO) m_ColorIndices[index].push_back(DO);
else bRes=false;
}
}
InvalidateCache ();
return bRes;
}
bool EScene::LoadSelection( LPCSTR fname )
{
u32 version = 0;
VERIFY( fname );
xr_string full_name;
full_name = fname;
ELog.Msg( mtInformation, "EScene: loading part %s...", fname );
bool res = true;
if (FS.exist(full_name.c_str())){
SelectObjects( false );
IReader* F = FS.r_open(full_name.c_str());
// Version
R_ASSERT(F->r_chunk(CHUNK_VERSION, &version));
if (version!=CURRENT_FILE_VERSION){
ELog.DlgMsg( mtError, "EScene: unsupported file version. Can't load Level.");
UI->UpdateScene();
FS.r_close(F);
return false;
}
// Objects
if (!ReadObjectsStream(*F,CHUNK_OBJECT_LIST,OnLoadSelectionAppendObject,0))
{
ELog.DlgMsg(mtError,"EScene. Failed to load selection.");
res = false;
}
SceneToolsMapPairIt _I = m_SceneTools.begin();
SceneToolsMapPairIt _E = m_SceneTools.end();
for (; _I!=_E; _I++)
if (_I->second&&_I->second->IsEnabled()&&_I->second->IsEditable()){
IReader* chunk = F->open_chunk(CHUNK_TOOLS_DATA+_I->first);
if (chunk){
_I->second->LoadSelection(*chunk);
chunk->close ();
}
}
// Synchronize
SynchronizeObjects();
FS.r_close(F);
}
return res;
}
bool EScene::ReadObjectStream(IReader& F, CCustomObject*& O)
{
ObjClassID clsid =OBJCLASS_DUMMY;
R_ASSERT (F.find_chunk(CHUNK_OBJECT_CLASS));
clsid = ObjClassID(F.r_u32());
O = GetOTool(clsid)->CreateObject(0,0);
IReader* S = F.open_chunk(CHUNK_OBJECT_BODY);
R_ASSERT (S);
bool bRes = O->LoadStream(*S);
S->close ();
if (!bRes)
xr_delete (O);
return bRes;
}
bool CEditableObject::LoadObject(const char* fname)
{
if (FS.exist(fname)){
int age = FS.get_file_age (fname); VERIFY3(age>0,"Invalid file age:",fname);
IReader* F = FS.r_open (fname); R_ASSERT(F);
IReader* OBJ = F->open_chunk (EOBJ_CHUNK_OBJECT_BODY);
R_ASSERT2 (OBJ,"Corrupted file.");
bool bRes = Load(*OBJ);
OBJ->close();
FS.r_close(F);
if (bRes){
m_LoadName = fname;
m_ObjectVersion = age;
}
return bRes;
}
return false;
}
void CRender::LoadVisuals(IReader *fs)
{
IReader* chunk = 0;
u32 index = 0;
dxRender_Visual* V = 0;
ogf_header H;
while ((chunk=fs->open_chunk(index))!=0)
{
chunk->r_chunk_safe (OGF_HEADER,&H,sizeof(H));
V = Models->Instance_Create (H.type);
V->Load(0,chunk,0);
Visuals.push_back(V);
chunk->close();
index++;
}
}
BOOL EScene::LoadLevelPart(ESceneToolBase* M, LPCSTR map_name)
{
if(M->can_use_inifile())
return LoadLevelPartLTX(M, map_name);
if (FS.exist(map_name))
{
// check locking
M->m_EditFlags.set(ESceneToolBase::flReadonly,FALSE);
IReader* R = FS.r_open (map_name);
VERIFY (R);
// check level part GUID
R_ASSERT (R->find_chunk (CHUNK_TOOLS_GUID));
xrGUID guid;
R->r (&guid,sizeof(guid));
if (guid!=m_GUID)
{
ELog.DlgMsg (mtError,"Skipping invalid version of level part: '%s\\%s.part'",EFS.ExtractFileName(map_name).c_str(),M->ClassName());
FS.r_close (R);
return FALSE;
}
// read data
IReader* chunk = R->open_chunk (CHUNK_TOOLS_DATA+M->ClassID);
if(chunk!=NULL)
{
M->LoadStream (*chunk);
chunk->close ();
}else
{
ELog.DlgMsg (mtError,"Skipping corrupted version of level part: '%s\\%s.part'",EFS.ExtractFileName(map_name).c_str(),M->ClassName());
FS.r_close (R);
return FALSE;
}
//success
FS.r_close (R);
return TRUE;
}
return TRUE;
}
bool EScene::Load(LPCSTR map_name, bool bUndo)
{
u32 version = 0;
if (!map_name||(0==map_name[0])) return false;
xr_string full_name;
full_name = map_name;
ELog.Msg( mtInformation, "EScene: loading '%s'", map_name);
if (FS.exist(full_name.c_str()))
{
CTimer T; T.Start();
// read main level
IReader* F = FS.r_open(full_name.c_str()); VERIFY(F);
// Version
R_ASSERT (F->r_chunk(CHUNK_VERSION, &version));
if (version!=CURRENT_FILE_VERSION)
{
ELog.DlgMsg( mtError, "EScene: unsupported file version. Can't load Level.");
UI->UpdateScene();
FS.r_close(F);
return false;
}
// Lev. ops.
IReader* LOP = F->open_chunk(CHUNK_LEVELOP);
if (LOP)
{
m_LevelOp.Read (*LOP);
LOP->close ();
}else
{
ELog.DlgMsg (mtError, "Skipping old version of level options.\nCheck level options after loading.");
}
//
if (F->find_chunk(CHUNK_CAMERA))
{
Fvector hpb, pos;
F->r_fvector3 (hpb);
F->r_fvector3 (pos);
EDevice.m_Camera.Set(hpb,pos);
EDevice.m_Camera.SetStyle(EDevice.m_Camera.GetStyle());
}
if (F->find_chunk(CHUNK_TOOLS_GUID))
{
F->r (&m_GUID,sizeof(m_GUID));
}
if (F->find_chunk(CHUNK_LEVEL_TAG))
{
F->r_stringZ (m_OwnerName);
F->r (&m_CreateTime,sizeof(m_CreateTime));
}else
{
m_OwnerName = "";
m_CreateTime = 0;
}
DWORD obj_cnt = 0;
if (F->find_chunk(CHUNK_OBJECT_COUNT))
obj_cnt = F->r_u32();
SPBItem* pb = UI->ProgressStart(obj_cnt,"Loading objects...");
ReadObjectsStream (*F,CHUNK_OBJECT_LIST,OnLoadAppendObject,pb);
UI->ProgressEnd (pb);
SceneToolsMapPairIt _I = m_SceneTools.begin();
SceneToolsMapPairIt _E = m_SceneTools.end();
for (; _I!=_E; ++_I)
{
if (_I->second)
{
IReader* chunk = F->open_chunk(CHUNK_TOOLS_DATA+_I->first);
if (chunk){
_I->second->LoadStream(*chunk);
chunk->close ();
}else{
if (!bUndo && _I->second->IsEnabled() && (_I->first!=OBJCLASS_DUMMY))
{
LoadLevelPart (_I->second,LevelPartName(map_name,_I->first).c_str());
}
}
}
}
// snap list
if (F->find_chunk(CHUNK_SNAPOBJECTS))
{
shared_str buf;
int cnt = F->r_u32();
if (cnt)
{
for (int i=0; i<cnt; ++i)
{
F->r_stringZ (buf);
CCustomObject* O = FindObjectByName(buf.c_str(),OBJCLASS_SCENEOBJECT);
if (!O)
ELog.Msg(mtError,"EScene: Can't find snap object '%s'.",buf.c_str());
else
m_ESO_SnapObjects.push_back(O);
}
}
UpdateSnapList();
}
Msg("EScene: %d objects loaded, %3.2f sec", ObjCount(), T.GetElapsed_sec() );
UI->UpdateScene(true);
FS.r_close(F);
SynchronizeObjects();
if (!bUndo)
m_RTFlags.set(flRT_Unsaved|flRT_Modified,FALSE);
return true;
}else
{
ELog.Msg(mtError,"Can't find file: '%s'",map_name);
}
return false;
}
bool EScene::ReadObjectsStream(IReader& F, u32 chunk_id, TAppendObject on_append, SPBItem* pb)
{
R_ASSERT (on_append);
bool bRes = true;
IReader* OBJ = F.open_chunk(chunk_id);
if (OBJ)
{
IReader* O = OBJ->open_chunk(0);
for (int count=1; O; ++count)
{
CCustomObject* obj =NULL;
if (ReadObjectStream(*O, obj))
{
LPCSTR obj_name = obj->Name;
CCustomObject* existing = FindObjectByName(obj_name,obj->ClassID);
if(existing)
{
if(g_frmConflictLoadObject->m_result!=2 && g_frmConflictLoadObject->m_result!=4 && g_frmConflictLoadObject->m_result!=6)
{
g_frmConflictLoadObject->m_existing_object = existing;
g_frmConflictLoadObject->m_new_object = obj;
g_frmConflictLoadObject->Prepare ();
g_frmConflictLoadObject->ShowModal ();
}
switch(g_frmConflictLoadObject->m_result)
{
case 1: //Overwrite
case 2: //Overwrite All
{
bool res = RemoveObject (existing, true, true);
if(!res)
Msg("! RemoveObject [%s] failed", existing->Name);
else
xr_delete(existing);
}break;
case 3: //Insert new
case 4: //Insert new All
{
string256 buf;
GenObjectName (obj->ClassID, buf, obj->Name);
obj->Name = buf;
}break;
case 0: //Cancel
case 5: //Skip
case 6: //Skip All
{
xr_delete(obj);
}break;
}
}
if (obj && !on_append(obj))
xr_delete(obj);}
else
bRes = false;
O->close ();
O = OBJ->open_chunk(count);
if (pb)
pb->Inc();
}
OBJ->close();
}
return bRes;
}
void game_sv_GameState::Create (shared_str &options)
{
string_path fn_game;
m_item_respawner.clear_respawns();
if (FS.exist(fn_game, "$level$", "level.game"))
{
IReader *F = FS.r_open (fn_game);
IReader *O = 0;
// Load RPoints
if (0!=(O = F->open_chunk (RPOINT_CHUNK)))
{
for (int id=0; O->find_chunk(id); ++id)
{
RPoint R;
u8 team;
u8 type;
u16 GameType;
shared_str rp_profile;
O->r_fvector3 (R.P);
O->r_fvector3 (R.A);
team = O->r_u8 ();
type = O->r_u8 ();
GameType = O->r_u16 ();
if(type==rptItemSpawn)
O->r_stringZ (rp_profile);
if (GameType != EGameIDs(u16(-1)))
{
if ((Type() == eGameIDCaptureTheArtefact) && (GameType & eGameIDCaptureTheArtefact))
{
team = team - 1;
R_ASSERT2( ((team >= 0) && (team < 4)) ||
(type != rptActorSpawn),
"Problem with CTA Team indexes. Propably you have added rpoint of team 0 for cta game type.");
}
if ((!(GameType & eGameIDDeathmatch) && (Type() == eGameIDDeathmatch)) ||
(!(GameType & eGameIDTeamDeathmatch) && (Type() == eGameIDTeamDeathmatch)) ||
(!(GameType & eGameIDArtefactHunt) && (Type() == eGameIDArtefactHunt)) ||
(!(GameType & eGameIDCaptureTheArtefact) && (Type() == eGameIDCaptureTheArtefact))
)
{
continue;
};
};
switch (type)
{
case rptActorSpawn:
{
rpoints[team].push_back (R);
for (int i=0; i<int(rpoints[team].size())-1; i++)
{
RPoint rp = rpoints[team][i];
float dist = R.P.distance_to_xz(rp.P)/2;
if (dist<rpoints_MinDist[team])
rpoints_MinDist[team] = dist;
dist = R.P.distance_to(rp.P)/2;
if (dist<rpoints_Dist[team])
rpoints_Dist[team] = dist;
};
}break;
case rptItemSpawn:
{
m_item_respawner.add_new_rpoint(rp_profile, R);
}
};
};
O->close();
}
FS.r_close (F);
}
if (!g_dedicated_server)
{
// loading scripts
ai().script_engine().remove_script_process(ScriptEngine::eScriptProcessorGame);
string_path S;
FS.update_path (S,"$game_config$","script.ltx");
CInifile *l_tpIniFile = xr_new<CInifile>(S);
R_ASSERT (l_tpIniFile);
if( l_tpIniFile->section_exist( type_name() ) )
if (l_tpIniFile->r_string(type_name(),"script"))
ai().script_engine().add_script_process(ScriptEngine::eScriptProcessorGame,xr_new<CScriptProcess>("game",l_tpIniFile->r_string(type_name(),"script")));
else
ai().script_engine().add_script_process(ScriptEngine::eScriptProcessorGame,xr_new<CScriptProcess>("game",""));
xr_delete (l_tpIniFile);
}
//---------------------------------------------------------------------
ConsoleCommands_Create();
//---------------------------------------------------------------------
// CCC_LoadCFG_custom* pTmp = xr_new<CCC_LoadCFG_custom>("sv_");
// pTmp->Execute (Console->ConfigFile);
// xr_delete (pTmp);
//---------------------------------------------------------------------
LPCSTR svcfg_ltx_name = "-svcfg ";
if (strstr(Core.Params, svcfg_ltx_name))
{
string_path svcfg_name = "";
int sz = xr_strlen(svcfg_ltx_name);
sscanf (strstr(Core.Params,svcfg_ltx_name)+sz,"%[^ ] ",svcfg_name);
// if (FS.exist(svcfg_name))
{
Console->ExecuteScript(svcfg_name);
}
};
//---------------------------------------------------------------------
ReadOptions(options);
}
void global_claculation_data::xrLoad()
{
string_path N;
FS.update_path ( N, "$game_data$", "shaders_xrlc.xr" );
g_shaders_xrlc = new Shader_xrLC_LIB();
g_shaders_xrlc->Load ( N );
// Load CFORM
{
FS.update_path (N,"$level$","build.cform");
IReader* fs = FS.r_open("$level$","build.cform");
R_ASSERT (fs->find_chunk(0));
hdrCFORM H;
fs->r (&H,sizeof(hdrCFORM));
R_ASSERT (CFORM_CURRENT_VERSION==H.version);
Fvector* verts = (Fvector*)fs->pointer();
CDB::TRI* tris = (CDB::TRI*)(verts+H.vertcount);
RCAST_Model.build ( verts, H.vertcount, tris, H.facecount );
Msg("* Level CFORM: %dK",RCAST_Model.memory()/1024);
g_rc_faces.resize (H.facecount);
R_ASSERT(fs->find_chunk(1));
fs->r (&*g_rc_faces.begin(),g_rc_faces.size()*sizeof(b_rc_face));
LevelBB.set (H.aabb);
}
{
slots_data.Load( );
}
// Lights
{
IReader* fs = FS.r_open("$level$","build.lights");
IReader* F; u32 cnt; R_Light* L;
// rgb
F = fs->open_chunk (0);
cnt = F->length()/sizeof(R_Light);
L = (R_Light*)F->pointer();
g_lights.rgb.assign (L,L+cnt);
F->close ();
// hemi
F = fs->open_chunk (1);
cnt = F->length()/sizeof(R_Light);
L = (R_Light*)F->pointer();
g_lights.hemi.assign(L,L+cnt);
F->close ();
// sun
F = fs->open_chunk (2);
cnt = F->length()/sizeof(R_Light);
L = (R_Light*)F->pointer();
g_lights.sun.assign (L,L+cnt);
F->close ();
FS.r_close (fs);
}
// Load level data
{
IReader* fs = FS.r_open ("$level$","build.prj");
IReader* F;
// Version
u32 version;
fs->r_chunk (EB_Version,&version);
R_ASSERT(XRCL_CURRENT_VERSION==version);
// Header
fs->r_chunk (EB_Parameters,&g_params);
// Load level data
transfer("materials", g_materials, *fs, EB_Materials);
transfer("shaders_xrlc",g_shader_compile, *fs, EB_Shaders_Compile);
post_process_materials( *g_shaders_xrlc, g_shader_compile, g_materials );
// process textures
#ifdef DEBUG
xr_vector<b_texture> dbg_textures;
#endif
Status ("Processing textures...");
{
Surface_Init ();
F = fs->open_chunk (EB_Textures);
u32 tex_count = F->length()/sizeof(b_texture);
for (u32 t=0; t<tex_count; t++)
{
Progress (float(t)/float(tex_count));
b_texture TEX;
F->r (&TEX,sizeof(TEX));
#ifdef DEBUG
dbg_textures.push_back( TEX );
#endif
b_BuildTexture BT;
CopyMemory (&BT,&TEX,sizeof(TEX));
// load thumbnail
LPSTR N = BT.name;
if (strchr(N,'.')) *(strchr(N,'.')) = 0;
strlwr (N);
if (0==xr_strcmp(N,"level_lods")) {
// HACK for merged lod textures
BT.dwWidth = 1024;
BT.dwHeight = 1024;
BT.bHasAlpha= TRUE;
BT.pSurface = 0;
} else {
strcat (N,".thm");
IReader* THM = FS.r_open("$game_textures$",N);
R_ASSERT2 (THM, N);
// version
u32 version = 0;
R_ASSERT (THM->r_chunk(THM_CHUNK_VERSION,&version));
// if( version!=THM_CURRENT_VERSION ) FATAL ("Unsupported version of THM file.");
// analyze thumbnail information
R_ASSERT(THM->find_chunk(THM_CHUNK_TEXTUREPARAM));
THM->r (&BT.THM.fmt,sizeof(STextureParams::ETFormat));
BT.THM.flags.assign (THM->r_u32());
BT.THM.border_color = THM->r_u32();
BT.THM.fade_color = THM->r_u32();
BT.THM.fade_amount = THM->r_u32();
BT.THM.mip_filter = THM->r_u32();
BT.THM.width = THM->r_u32();
BT.THM.height = THM->r_u32();
BOOL bLOD=FALSE;
if (N[0]=='l' && N[1]=='o' && N[2]=='d' && N[3]=='\\') bLOD = TRUE;
// load surface if it has an alpha channel or has "implicit lighting" flag
BT.dwWidth = BT.THM.width;
BT.dwHeight = BT.THM.height;
BT.bHasAlpha = BT.THM.HasAlphaChannel();
BT.pSurface = 0;
if (!bLOD)
{
if (BT.bHasAlpha || BT.THM.flags.test(STextureParams::flImplicitLighted))
{
clMsg ("- loading: %s",N);
u32 w=0, h=0;
BT.pSurface = Surface_Load(N,w,h);
R_ASSERT2 (BT.pSurface,"Can't load surface");
if ((w != BT.dwWidth) || (h != BT.dwHeight))
Msg ("! THM doesn't correspond to the texture: %dx%d -> %dx%d", BT.dwWidth, BT.dwHeight, w, h);
BT.Vflip ();
} else {
// Free surface memory
}
}
}
// save all the stuff we've created
g_textures.push_back (BT);
}
}
}
}
void CKinematics::Load(const char* N, IReader *data, u32 dwFlags)
{
//Msg ("skeleton: %s",N);
inherited::Load (N, data, dwFlags);
pUserData = NULL;
m_lod = NULL;
// loading lods
IReader* LD = data->open_chunk(OGF_S_LODS);
if (LD)
{
string_path short_name;
strcpy_s (short_name,sizeof(short_name),N);
if (strext(short_name)) *strext(short_name)=0;
// From stream
{
string_path lod_name;
LD->r_string (lod_name, sizeof(lod_name));
//. strconcat (sizeof(name_load),name_load, short_name, ":lod:", lod_name.c_str());
m_lod = ::Render->model_CreateChild(lod_name, NULL);
VERIFY3(m_lod,"Cant create LOD model for", N);
//. VERIFY2 (m_lod->Type==MT_HIERRARHY || m_lod->Type==MT_PROGRESSIVE || m_lod->Type==MT_NORMAL,lod_name.c_str());
/*
strconcat (name_load, short_name, ":lod:1");
m_lod = ::Render->model_CreateChild(name_load,LD);
VERIFY (m_lod->Type==MT_SKELETON_GEOMDEF_PM || m_lod->Type==MT_SKELETON_GEOMDEF_ST);
*/
}
LD->close ();
}
#ifndef _EDITOR
// User data
IReader* UD = data->open_chunk(OGF_S_USERDATA);
pUserData = UD?xr_new<CInifile>(UD,FS.get_path("$game_config$")->m_Path):0;
if (UD) UD->close();
#endif
// Globals
bone_map_N = xr_new<accel> ();
bone_map_P = xr_new<accel> ();
bones = xr_new<vecBones> ();
bone_instances = NULL;
// Load bones
#pragma todo("container is created in stack!")
xr_vector<shared_str> L_parents;
R_ASSERT (data->find_chunk(OGF_S_BONE_NAMES));
visimask.zero ();
int dwCount = data->r_u32();
// Msg ("!!! %d bones",dwCount);
// if (dwCount >= 64) Msg ("!!! More than 64 bones is a crazy thing! (%d), %s",dwCount,N);
VERIFY3 (dwCount < 64, "More than 64 bones is a crazy thing!",N);
for (; dwCount; dwCount--) {
string256 buf;
// Bone
u16 ID = u16(bones->size());
data->r_stringZ (buf,sizeof(buf)); strlwr(buf);
CBoneData* pBone = CreateBoneData(ID);
pBone->name = shared_str(buf);
pBone->child_faces.resize (children.size());
bones->push_back (pBone);
bone_map_N->push_back (mk_pair(pBone->name,ID));
bone_map_P->push_back (mk_pair(pBone->name,ID));
// It's parent
data->r_stringZ (buf,sizeof(buf)); strlwr(buf);
L_parents.push_back (buf);
data->r (&pBone->obb,sizeof(Fobb));
visimask.set (u64(1)<<ID,TRUE);
}
std::sort (bone_map_N->begin(),bone_map_N->end(),pred_sort_N);
std::sort (bone_map_P->begin(),bone_map_P->end(),pred_sort_P);
// Attach bones to their parents
iRoot = BI_NONE;
for (u32 i=0; i<bones->size(); i++) {
shared_str P = L_parents[i];
CBoneData* B = (*bones)[i];
if (!P||!P[0]) {
// no parent - this is root bone
R_ASSERT (BI_NONE==iRoot);
iRoot = u16(i);
B->SetParentID(BI_NONE);
continue;
} else {
u16 ID = LL_BoneID(P);
R_ASSERT (ID!=BI_NONE);
(*bones)[ID]->children.push_back(B);
B->SetParentID(ID);
}
}
R_ASSERT (BI_NONE != iRoot);
// Free parents
L_parents.clear();
// IK data
IReader* IKD = data->open_chunk(OGF_S_IKDATA);
if (IKD){
for (u32 i=0; i<bones->size(); i++) {
CBoneData* B = (*bones)[i];
u16 vers = (u16)IKD->r_u32();
IKD->r_stringZ (B->game_mtl_name);
IKD->r (&B->shape,sizeof(SBoneShape));
B->IK_data.Import(*IKD,vers);
Fvector vXYZ,vT;
IKD->r_fvector3 (vXYZ);
IKD->r_fvector3 (vT);
B->bind_transform.setXYZi(vXYZ);
B->bind_transform.translate_over(vT);
B->mass = IKD->r_float();
IKD->r_fvector3 (B->center_of_mass);
}
// calculate model to bone converting matrix
(*bones)[LL_GetBoneRoot()]->CalculateM2B(Fidentity);
IKD->close();
}
// after load process
{
for (u16 child_idx=0; child_idx<(u16)children.size(); child_idx++)
LL_GetChild(child_idx)->AfterLoad (this,child_idx);
}
// unique bone faces
{
for (u32 bone_idx=0; bone_idx<bones->size(); bone_idx++) {
CBoneData* B = (*bones)[bone_idx];
for (u32 child_idx=0; child_idx<children.size(); child_idx++){
CBoneData::FacesVec faces = B->child_faces[child_idx];
std::sort (faces.begin(),faces.end());
CBoneData::FacesVecIt new_end = std::unique(faces.begin(),faces.end());
faces.erase (new_end,faces.end());
B->child_faces[child_idx].clear_and_free();
B->child_faces[child_idx] = faces;
}
}
}
// reset update_callback
Update_Callback = NULL;
// reset update frame
wm_frame = u32(-1);
LL_Validate ();
}
bool CEditableObject::Load(IReader& F)
{
bool bRes = true;
do{
u32 version = 0;
shared_str buf;
shared_str sh_name;
R_ASSERT(F.r_chunk(EOBJ_CHUNK_VERSION,&version));
if (version!=EOBJ_CURRENT_VERSION){
ELog.DlgMsg( mtError, "CEditableObject: unsupported file version. Object can't load.");
bRes = false;
break;
}
R_ASSERT(F.r_chunk(EOBJ_CHUNK_FLAGS, &m_Flags.flags));
if (F.find_chunk (EOBJ_CHUNK_CLASSSCRIPT)){
F.r_stringZ (m_ClassScript);
}
if (F.find_chunk (EOBJ_CHUNK_LODS)){
F.r_stringZ (m_LODs);
}
// surfaces
if (F.find_chunk(EOBJ_CHUNK_SURFACES3)){
u32 cnt = F.r_u32();
m_Surfaces.resize(cnt);
for (SurfaceIt s_it=m_Surfaces.begin(); s_it!=m_Surfaces.end(); s_it++){
*s_it = xr_new<CSurface>();
F.r_stringZ (buf); (*s_it)->SetName (buf.c_str());
F.r_stringZ (buf); (*s_it)->SetShader (buf.c_str());
F.r_stringZ (buf); (*s_it)->SetShaderXRLC (buf.c_str());
F.r_stringZ (buf); (*s_it)->SetGameMtl (buf.c_str());
F.r_stringZ (buf); (*s_it)->SetTexture (buf.c_str());
F.r_stringZ (buf); (*s_it)->SetVMap (buf.c_str());
(*s_it)->m_Flags.assign(F.r_u32());
(*s_it)->SetFVF (F.r_u32());
cnt = F.r_u32();
if (cnt>1) ELog.DlgMsg(mtError,"Object surface '%s' has more than one TC's.",buf.c_str());
R_ASSERT(1<=cnt);
}
}else if (F.find_chunk(EOBJ_CHUNK_SURFACES2)){
u32 cnt = F.r_u32();
m_Surfaces.resize(cnt);
for (SurfaceIt s_it=m_Surfaces.begin(); s_it!=m_Surfaces.end(); s_it++){
*s_it = xr_new<CSurface>();
F.r_stringZ (buf); (*s_it)->SetName (buf.c_str());
F.r_stringZ (buf); (*s_it)->SetShader (buf.c_str());
F.r_stringZ (buf); (*s_it)->SetShaderXRLC (buf.c_str());
F.r_stringZ (buf); (*s_it)->SetTexture (buf.c_str());
F.r_stringZ (buf); (*s_it)->SetVMap (buf.c_str());
(*s_it)->m_Flags.assign(F.r_u32());
(*s_it)->SetFVF (F.r_u32());
cnt = F.r_u32();
if (cnt>1) ELog.DlgMsg(mtError,"Object surface '%s' has more than one TC's.",buf.c_str());
R_ASSERT(1<=cnt);
}
}else{
R_ASSERT(F.find_chunk(EOBJ_CHUNK_SURFACES));
u32 cnt = F.r_u32();
m_Surfaces.resize(cnt);
for (SurfaceIt s_it=m_Surfaces.begin(); s_it!=m_Surfaces.end(); s_it++){
*s_it = xr_new<CSurface>();
F.r_stringZ(buf);
(*s_it)->SetName(buf.c_str());
F.r_stringZ(sh_name);
(*s_it)->m_Flags.set(CSurface::sf2Sided,!!F.r_u8());
(*s_it)->SetFVF (F.r_u32());
cnt = F.r_u32();
if (cnt>1) ELog.DlgMsg(mtError,"Object surface '%s' has more than one TC's.",buf.c_str());
R_ASSERT(1<=cnt);
F.r_stringZ (buf); (*s_it)->SetTexture(buf.c_str());
F.r_stringZ (buf); (*s_it)->SetVMap(buf.c_str());
(*s_it)->SetShader (sh_name.c_str());
(*s_it)->SetShaderXRLC ("default");
}
// surfaces xrlc part
if(F.find_chunk(EOBJ_CHUNK_SURFACES_XRLC))
for (s_it=m_Surfaces.begin(); s_it!=m_Surfaces.end(); s_it++){
F.r_stringZ(buf); (*s_it)->SetShaderXRLC(buf.c_str());
}
}
// Load meshes
IReader* OBJ = F.open_chunk(EOBJ_CHUNK_EDITMESHES);
if(OBJ){
IReader* M = OBJ->open_chunk(0);
for (int count=1; M; count++) {
CEditableMesh* mesh=xr_new<CEditableMesh>(this);
if (mesh->LoadMesh(*M))
m_Meshes.push_back(mesh);
else{
ELog.DlgMsg( mtError, "CEditableObject: Can't load mesh '%s'!", *mesh->m_Name );
xr_delete(mesh);
bRes = false;
}
M->close();
if (!bRes) break;
M = OBJ->open_chunk(count);
}
OBJ->close();
}
// bones
if (bRes){
IReader* B_CHUNK = F.open_chunk(EOBJ_CHUNK_BONES2);
if (B_CHUNK){
int chunk = 0;
IReader* O;
while (0!=(O=B_CHUNK->open_chunk(chunk++))){
m_Bones.push_back(xr_new<CBone>());
m_Bones.back()->Load_1(*O);
O->close();
}
B_CHUNK->close();
PrepareBones();
}else if (F.find_chunk(EOBJ_CHUNK_BONES)){
m_Bones.resize(F.r_u32());
for (BoneIt b_it=m_Bones.begin(); b_it!=m_Bones.end(); b_it++){
*b_it = xr_new<CBone>();
(*b_it)->Load_0(F);
}
PrepareBones();
}
// skeleton motions
if (F.find_chunk(EOBJ_CHUNK_SMOTIONS)){
m_SMotions.resize(F.r_u32());
for (SMotionIt s_it=m_SMotions.begin(); s_it!=m_SMotions.end(); s_it++){
*s_it = xr_new<CSMotion>();
if (!(*s_it)->Load(F)){
Log ("!Motions has different version. Load failed.");
xr_delete(*s_it);
m_SMotions.clear();
break;
}
// resort bone_mots
(*s_it)->SortBonesBySkeleton(m_Bones);
}
}
if (F.find_chunk(EOBJ_CHUNK_SMOTIONS2)){
F.r_stringZ (m_SMotionRefs);
}
}
// bone parts
if (bRes){
if (F.find_chunk(EOBJ_CHUNK_BONEPARTS)){
m_BoneParts.resize(F.r_u32());
bool bBPok = true;
for (BPIt bp_it=m_BoneParts.begin(); bp_it!=m_BoneParts.end(); bp_it++){
F.r_stringZ (buf); bp_it->alias=buf;
bp_it->bones.resize(F.r_u32());
for (RStringVecIt s_it=bp_it->bones.begin(); s_it!=bp_it->bones.end(); s_it++){
int idx = F.r_u32();
if ((idx>=0)&&(idx<(int)m_Bones.size())){
*s_it = m_Bones[idx]->Name();
}else{
Log ("!Invalid bone parts.",GetName());
bBPok = false;
break;
}
}
if (!bBPok) break;
}
if (!bBPok) m_BoneParts.clear();
if (!m_BoneParts.empty()&&!VerifyBoneParts())
Log ("!Invalid bone parts. Found duplicate bones in object '%s'.",GetName());
}else if (F.find_chunk(EOBJ_CHUNK_BONEPARTS2)){
m_BoneParts.resize(F.r_u32());
for (BPIt bp_it=m_BoneParts.begin(); bp_it!=m_BoneParts.end(); bp_it++){
F.r_stringZ (buf); bp_it->alias=buf;
bp_it->bones.resize(F.r_u32());
for (RStringVecIt s_it=bp_it->bones.begin(); s_it!=bp_it->bones.end(); s_it++)
F.r_stringZ(*s_it);
}
if (!m_BoneParts.empty()&&!VerifyBoneParts())
Log ("!Invalid bone parts. Found duplicate bones in object '%s'.",GetName());
}
}
if (bRes){
if (F.find_chunk (EOBJ_CHUNK_ACTORTRANSFORM)){
F.r_fvector3 (a_vPosition);
F.r_fvector3 (a_vRotate);
}
if (F.find_chunk (EOBJ_CHUNK_DESC)){
F.r_stringZ (m_CreateName);
F.r (&m_CreateTime,sizeof(m_CreateTime));
F.r_stringZ (m_ModifName);
F.r (&m_ModifTime,sizeof(m_ModifTime));
}
ResetSAnimation();
}
if (!bRes) break;
UpdateBox ();
VerifyMeshNames ();
}while(0);
return bRes;
}
CLevelGameGraph (
LPCSTR graph_file_name,
LPCSTR raw_cross_table_file_name,
CGameGraph::SLevel *tLevel,
LPCSTR S,
u32 dwOffset,
u32 dwLevelID,
CInifile *Ini
)
{
m_tLevel = *tLevel;
m_dwOffset = dwOffset;
m_tpLevelPoints.clear ();
FILE_NAME caFileName;
// loading graph
strcpy_s (caFileName,graph_file_name);
m_tpGraph = new CGameGraph(caFileName);
strcpy_s (caFileName,raw_cross_table_file_name);
CGameLevelCrossTable *l_tpCrossTable = new CGameLevelCrossTable(caFileName);
CLevelGraph *l_tpAI_Map = new CLevelGraph(S);
VERIFY2 (l_tpCrossTable->header().level_guid() == l_tpAI_Map->header().guid(), "cross table doesn't correspond to the AI-map, rebuild graph!");
VERIFY2 (l_tpCrossTable->header().game_guid() == m_tpGraph->header().guid(), "cross table doesn't correspond to the graph, rebuild graph!");
VERIFY2 (m_tpGraph->header().level(GameGraph::_LEVEL_ID(0)).guid() == l_tpAI_Map->header().guid(), "cross table doesn't correspond to the AI-map, rebuild graph!");
VERIFY (l_tpAI_Map->header().vertex_count() == l_tpCrossTable->header().level_vertex_count());
VERIFY (m_tpGraph->header().vertex_count() == l_tpCrossTable->header().game_vertex_count());
tLevel->m_guid = l_tpAI_Map->header().guid();
{
for (GameGraph::_GRAPH_ID i=0, n = m_tpGraph->header().vertex_count(); i<n; ++i)
if ((!l_tpAI_Map->valid_vertex_id(m_tpGraph->vertex(i)->level_vertex_id()) ||
(l_tpCrossTable->vertex(m_tpGraph->vertex(i)->level_vertex_id()).game_vertex_id() != i) ||
!l_tpAI_Map->inside(m_tpGraph->vertex(i)->level_vertex_id(),m_tpGraph->vertex(i)->level_point()))) {
Msg ("! Graph doesn't correspond to the cross table");
R_ASSERT2 (false,"Graph doesn't correspond to the cross table");
}
}
m_tpVertices.resize (m_tpGraph->header().vertex_count());
GRAPH_VERTEX_IT B = m_tpVertices.begin();
GRAPH_VERTEX_IT I = B;
GRAPH_VERTEX_IT E = m_tpVertices.end();
for ( ; I != E; I++) {
(*I).tLocalPoint = m_tpGraph->vertex(int(I - B))->level_point();
(*I).tGlobalPoint.add (m_tpGraph->vertex(int(I - B))->game_point(),m_tLevel.offset());
(*I).tLevelID = dwLevelID;
(*I).tNodeID = m_tpGraph->vertex(int(I - B))->level_vertex_id();
Memory.mem_copy ((*I).tVertexTypes,m_tpGraph->vertex(int(I - B))->vertex_type(),GameGraph::LOCATION_TYPE_COUNT*sizeof(GameGraph::_LOCATION_ID));
(*I).tNeighbourCount = m_tpGraph->vertex(int(I - B))->edge_count();
CGameGraph::const_iterator b,i,e;
m_tpGraph->begin (int(I - B),i,e);
(*I).tpaEdges = (CGameGraph::CEdge*)xr_malloc((*I).tNeighbourCount*sizeof(CGameGraph::CEdge));
b = i;
for ( ; i != e; ++i) {
GameGraph::CEdge &edge = (*I).tpaEdges[i - b];
edge = *i;
VERIFY ((edge.vertex_id() + dwOffset) < (u32(1) << (8*sizeof(GameGraph::_GRAPH_ID))));
edge.m_vertex_id = (GameGraph::_GRAPH_ID)(edge.m_vertex_id + dwOffset);
}
(*I).dwPointOffset = 0;
vfGenerateDeathPoints (int(I - B),l_tpCrossTable,l_tpAI_Map,(*I).tDeathPointCount);
}
xr_delete (l_tpCrossTable);
xr_delete (l_tpAI_Map);
// updating cross-table
{
strcpy_s (caFileName,raw_cross_table_file_name);
CGameLevelCrossTable *tpCrossTable = new CGameLevelCrossTable(caFileName);
xr_vector<CGameLevelCrossTable::CCell> tCrossTableUpdate;
tCrossTableUpdate.resize(tpCrossTable->header().level_vertex_count());
for (int i=0; i<(int)tpCrossTable->header().level_vertex_count(); i++) {
tCrossTableUpdate[i] = tpCrossTable->vertex(i);
VERIFY (u32(tCrossTableUpdate[i].tGraphIndex) < tpCrossTable->header().game_vertex_count());
tCrossTableUpdate[i].tGraphIndex = tCrossTableUpdate[i].tGraphIndex + (GameGraph::_GRAPH_ID)dwOffset;
}
CGameLevelCrossTable::CHeader tCrossTableHeader;
tCrossTableHeader.dwVersion = XRAI_CURRENT_VERSION;
tCrossTableHeader.dwNodeCount = tpCrossTable->m_tCrossTableHeader.dwNodeCount;
tCrossTableHeader.dwGraphPointCount = tpCrossTable->m_tCrossTableHeader.dwGraphPointCount;
tCrossTableHeader.m_level_guid = tpCrossTable->m_tCrossTableHeader.m_level_guid;
tCrossTableHeader.m_game_guid = tGraphHeader.m_guid;
xr_delete (tpCrossTable);
m_cross_table.w(&tCrossTableHeader,sizeof(tCrossTableHeader));
for (int i=0; i<(int)tCrossTableHeader.dwNodeCount; i++)
m_cross_table.w(&(tCrossTableUpdate[i]),sizeof(tCrossTableUpdate[i]));
}
// fill vertex map
{
string_path fName;
strconcat (sizeof(fName),fName,S,"level.spawn");
IReader *F = FS.r_open(fName);
u32 id;
IReader *O = F->open_chunk_iterator(id);
for (int i=0; O; O = F->open_chunk_iterator(id,O)) {
NET_Packet P;
P.B.count = O->length();
O->r (P.B.data,P.B.count);
u16 ID;
P.r_begin (ID);
R_ASSERT (M_SPAWN==ID);
P.r_stringZ (fName);
CSE_Abstract *E = F_entity_Create(fName);
R_ASSERT3 (E,"Can't create entity.",fName);
// E->Spawn_Read (P);
CSE_ALifeGraphPoint *tpGraphPoint = smart_cast<CSE_ALifeGraphPoint*>(E);
if (tpGraphPoint) {
E->Spawn_Read (P);
Fvector tVector;
tVector = tpGraphPoint->o_Position;
GameGraph::_GRAPH_ID tGraphID = GameGraph::_GRAPH_ID(-1);
float fMinDistance = 1000000.f;
{
GRAPH_VERTEX_IT B = m_tpVertices.begin();
GRAPH_VERTEX_IT I = B;
GRAPH_VERTEX_IT E = m_tpVertices.end();
for ( ; I != E; I++) {
float fDistance = (*I).tLocalPoint.distance_to(tVector);
if (fDistance < fMinDistance) {
fMinDistance = fDistance;
tGraphID = GameGraph::_GRAPH_ID(I - B);
if (fMinDistance < EPS_L)
break;
}
}
}
if (fMinDistance < EPS_L) {
SConnectionVertex T;
LPSTR S;
S = xr_strdup(tpGraphPoint->name_replace());
T.caConnectName = xr_strdup(*tpGraphPoint->m_caConnectionPointName);
T.dwLevelID = dwfGetIDByLevelName(Ini,*tpGraphPoint->m_caConnectionLevelName);
// T.tGraphID = (GameGraph::_GRAPH_ID)i;
// T.tOldGraphID = tGraphID;
T.tOldGraphID = (GameGraph::_GRAPH_ID)i;
T.tGraphID = tGraphID;
bool ok = true;
VERTEX_MAP::const_iterator II = m_tVertexMap.begin();
VERTEX_MAP::const_iterator EE = m_tVertexMap.end();
for ( ; II != EE; ++II)
if (T.tOldGraphID == (*II).second.tOldGraphID) {
ok = false;
Msg ("Graph point %s is removed,because it has the same position as some another graph point",E->name_replace());
break;
}
if (ok) {
m_tVertexMap.insert (mk_pair(S,T));
i++;
}
}
}
F_entity_Destroy (E);
}
if (i != m_tpGraph->header().vertex_count())
Msg ("Graph for the level %s doesn't correspond to the graph points from Level Editor! (%d : %d)",*m_tLevel.name(),i,m_tpGraph->header().vertex_count());
VERTEX_MAP::const_iterator I = m_tVertexMap.begin();
VERTEX_MAP::const_iterator E = m_tVertexMap.end();
for ( ; I != E; ++I) {
R_ASSERT3 (!xr_strlen((*I).second.caConnectName) || ((*I).second.tGraphID < m_tpVertices.size()),"Rebuild graph for the level",*m_tLevel.name());
}
// VERIFY3 (i == m_tpGraph->header().vertex_count(), "Rebuild graph for the level ",m_tLevel.name());
O->close ();
FS.r_close (F);
}
};
HRESULT CRender::shader_compile (
LPCSTR name,
DWORD const* pSrcData,
UINT SrcDataLen,
LPCSTR pFunctionName,
LPCSTR pTarget,
DWORD Flags,
void*& result
)
{
D3DXMACRO defines [128];
int def_it = 0;
char sh_name[MAX_PATH] = "";
u32 len = 0;
// options
if (o.forceskinw) {
defines[def_it].Name = "SKIN_COLOR";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(o.forceskinw); ++len;
if (m_skinning<0) {
defines[def_it].Name = "SKIN_NONE";
defines[def_it].Definition = "1";
def_it ++;
sh_name[len]='1'; ++len;
}
else {
sh_name[len]='0'; ++len;
}
if (0==m_skinning) {
defines[def_it].Name = "SKIN_0";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(0==m_skinning); ++len;
if (1==m_skinning) {
defines[def_it].Name = "SKIN_1";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(1==m_skinning); ++len;
if (2==m_skinning) {
defines[def_it].Name = "SKIN_2";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(2==m_skinning); ++len;
if (3==m_skinning) {
defines[def_it].Name = "SKIN_3";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(3==m_skinning); ++len;
if (4==m_skinning) {
defines[def_it].Name = "SKIN_4";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(4==m_skinning); ++len;
// finish
defines[def_it].Name = 0;
defines[def_it].Definition = 0;
def_it ++;
R_ASSERT (def_it<128);
HRESULT _result = E_FAIL;
string_path folder_name, folder;
xr_strcpy ( folder, "r1\\objects\\r1\\" );
xr_strcat ( folder, name );
xr_strcat ( folder, "." );
char extension[3];
strncpy_s ( extension, pTarget, 2 );
xr_strcat ( folder, extension );
FS.update_path ( folder_name, "$game_shaders$", folder );
xr_strcat ( folder_name, "\\" );
m_file_set.clear( );
FS.file_list ( m_file_set, folder_name, FS_ListFiles | FS_RootOnly, "*");
string_path temp_file_name, file_name;
if ( !match_shader_id(name, sh_name, m_file_set, temp_file_name) ) {
string_path file;
xr_strcpy ( file, "shaders_cache\\r1\\" );
xr_strcat ( file, name );
xr_strcat ( file, "." );
xr_strcat ( file, extension );
xr_strcat ( file, "\\" );
xr_strcat ( file, sh_name );
FS.update_path ( file_name, "$app_data_root$", file);
}
else {
xr_strcpy ( file_name, folder_name );
xr_strcat ( file_name, temp_file_name );
}
if (FS.exist(file_name))
{
IReader* file = FS.r_open(file_name);
if (file->length()>4)
{
u32 crc = 0;
crc = file->r_u32();
boost::crc_32_type processor;
processor.process_block ( file->pointer(), ((char*)file->pointer()) + file->elapsed() );
u32 const real_crc = processor.checksum( );
if ( real_crc == crc ) {
_result = create_shader(pTarget, (DWORD*)file->pointer(), file->elapsed(), file_name, result, o.disasm);
}
}
file->close();
}
if (FAILED(_result))
{
includer Includer;
LPD3DXBUFFER pShaderBuf = NULL;
LPD3DXBUFFER pErrorBuf = NULL;
LPD3DXCONSTANTTABLE pConstants = NULL;
LPD3DXINCLUDE pInclude = (LPD3DXINCLUDE)&Includer;
_result = D3DXCompileShader((LPCSTR)pSrcData,SrcDataLen,defines,pInclude,pFunctionName,pTarget,Flags|D3DXSHADER_USE_LEGACY_D3DX9_31_DLL,&pShaderBuf,&pErrorBuf,&pConstants);
if (SUCCEEDED(_result)) {
IWriter* file = FS.w_open(file_name);
boost::crc_32_type processor;
processor.process_block ( pShaderBuf->GetBufferPointer(), ((char*)pShaderBuf->GetBufferPointer()) + pShaderBuf->GetBufferSize() );
u32 const crc = processor.checksum( );
file->w_u32 (crc);
file->w ( pShaderBuf->GetBufferPointer(), (u32)pShaderBuf->GetBufferSize());
FS.w_close (file);
_result = create_shader(pTarget, (DWORD*)pShaderBuf->GetBufferPointer(), pShaderBuf->GetBufferSize(), file_name, result, o.disasm);
}
else {
Log ("! ", file_name);
if ( pErrorBuf )
Log ("! error: ",(LPCSTR)pErrorBuf->GetBufferPointer());
else
Msg ("Can't compile shader hr=0x%08x", _result);
}
}
return _result;
}
//-----------------------------------------------------------------------
BOOL motions_value::load (LPCSTR N, IReader *data, vecBones* bones)
{
m_id = N;
bool bRes = true;
// Load definitions
U16Vec rm_bones (bones->size(),BI_NONE);
IReader* MP = data->open_chunk(OGF_S_SMPARAMS);
if (MP)
{
u16 vers = MP->r_u16();
u16 part_bone_cnt = 0;
string128 buf;
R_ASSERT3 (vers<=xrOGF_SMParamsVersion,"Invalid OGF/OMF version:",N);
// partitions
u16 part_count;
part_count = MP->r_u16();
for (u16 part_i=0; part_i<part_count; part_i++)
{
CPartDef& PART = m_partition[part_i];
MP->r_stringZ (buf,sizeof(buf));
PART.Name = _strlwr(buf);
PART.bones.resize (MP->r_u16());
for (xr_vector<u32>::iterator b_it=PART.bones.begin(); b_it<PART.bones.end(); b_it++)
{
MP->r_stringZ (buf,sizeof(buf));
u16 m_idx = u16 (MP->r_u32());
*b_it = find_bone_id (bones,buf);
#ifdef _EDITOR
if (*b_it==BI_NONE )
{
bRes = false;
Msg ("! Can't find bone: '%s'", buf);
}
if (rm_bones.size() <= m_idx)
{
bRes = false;
Msg ("! Can't load: '%s' invalid bones count", N);
}
#else
VERIFY3 (*b_it!=BI_NONE,"Can't find bone:", buf);
#endif
if (bRes) rm_bones[m_idx] = u16(*b_it);
}
part_bone_cnt = u16(part_bone_cnt + (u16)PART.bones.size());
}
#ifdef _EDITOR
if (part_bone_cnt!=(u16)bones->size()){
bRes = false;
Msg("! Different bone count[%s] [Object: '%d' <-> Motions: '%d']", N, bones->size(),part_bone_cnt);
}
#else
VERIFY3(part_bone_cnt==(u16)bones->size(),"Different bone count '%s'",N);
#endif
if (bRes)
{
// motion defs (cycle&fx)
u16 mot_count = MP->r_u16();
m_mdefs.resize (mot_count);
for (u16 mot_i=0; mot_i<mot_count; mot_i++)
{
MP->r_stringZ (buf,sizeof(buf));
shared_str nm = _strlwr (buf);
u32 dwFlags = MP->r_u32 ();
CMotionDef& D = m_mdefs[mot_i];
D.Load (MP,dwFlags,vers);
//. m_mdefs.push_back (D);
if (dwFlags&esmFX)
m_fx.insert (mk_pair(nm,mot_i));
else
m_cycle.insert (mk_pair(nm,mot_i));
m_motion_map.insert (mk_pair(nm,mot_i));
}
}
MP->close();
}else
{
xrDebug::Fatal (DEBUG_INFO,"Old skinned model version unsupported! (%s)",N);
}
if (!bRes) return false;
// Load animation
IReader* MS = data->open_chunk(OGF_S_MOTIONS);
if (!MS) return false;
u32 dwCNT = 0;
MS->r_chunk_safe (0,&dwCNT,sizeof(dwCNT));
VERIFY (dwCNT<0x3FFF); // MotionID 2 bit - slot, 14 bit - motion index
// set per bone motion size
for (u32 i=0; i<bones->size(); i++)
m_motions[bones->at(i)->name].resize(dwCNT);
// load motions
for (u16 m_idx=0; m_idx<(u16)dwCNT; m_idx++){
string128 mname;
R_ASSERT (MS->find_chunk(m_idx+1));
MS->r_stringZ (mname,sizeof(mname));
#ifdef _DEBUG
// sanity check
xr_strlwr (mname);
accel_map::iterator I= m_motion_map.find(mname);
VERIFY3 (I!=m_motion_map.end(),"Can't find motion:",mname);
VERIFY3 (I->second==m_idx,"Invalid motion index:",mname);
#endif
u32 dwLen = MS->r_u32();
for (u32 i=0; i<bones->size(); i++){
u16 bone_id = rm_bones[i];
VERIFY2 (bone_id!=BI_NONE,"Invalid remap index.");
CMotion& M = m_motions[bones->at(bone_id)->name][m_idx];
M.set_count (dwLen);
M.set_flags (MS->r_u8());
if (M.test_flag(flRKeyAbsent)) {
CKeyQR* r = (CKeyQR*)MS->pointer();
u32 crc_q = crc32(r,sizeof(CKeyQR));
M._keysR.create (crc_q,1,r);
MS->advance (1 * sizeof(CKeyQR));
}else{
u32 crc_q = MS->r_u32 ();
M._keysR.create (crc_q,dwLen,(CKeyQR*)MS->pointer());
MS->advance (dwLen * sizeof(CKeyQR));
}
if (M.test_flag(flTKeyPresent))
{
u32 crc_t = MS->r_u32 ();
if(M.test_flag(flTKey16IsBit))
{
M._keysT16.create (crc_t,dwLen,(CKeyQT16*)MS->pointer());
MS->advance (dwLen * sizeof(CKeyQT16));
}else
{
M._keysT8.create (crc_t,dwLen,(CKeyQT8*)MS->pointer());
MS->advance (dwLen * sizeof(CKeyQT8));
};
MS->r_fvector3 (M._sizeT);
MS->r_fvector3 (M._initT);
}else
{
MS->r_fvector3 (M._initT);
}
}
}
// Msg("Motions %d/%d %4d/%4d/%d, %s",p_cnt,m_cnt, m_load,m_total,m_r,N);
MS->close();
return bRes;
}
void CRender::level_Load(IReader* fs)
{
R_ASSERT (0!=g_pGameLevel);
R_ASSERT (!b_loaded);
// Begin
pApp->LoadBegin ();
dxRenderDeviceRender::Instance().Resources->DeferredLoad (TRUE);
IReader* chunk;
// Shaders
// g_pGamePersistent->LoadTitle ("st_loading_shaders");
g_pGamePersistent->LoadTitle ();
{
chunk = fs->open_chunk (fsL_SHADERS);
R_ASSERT2 (chunk,"Level doesn't builded correctly.");
u32 count = chunk->r_u32 ();
Shaders.resize (count);
for(u32 i=0; i<count; i++) // skip first shader as "reserved" one
{
string512 n_sh,n_tlist;
LPCSTR n = LPCSTR(chunk->pointer());
chunk->skip_stringZ ();
if (0==n[0]) continue;
xr_strcpy (n_sh,n);
LPSTR delim = strchr(n_sh,'/');
*delim = 0;
xr_strcpy (n_tlist,delim+1);
Shaders[i] = dxRenderDeviceRender::Instance().Resources->Create(n_sh,n_tlist);
}
chunk->close();
}
// Components
Wallmarks = xr_new<CWallmarksEngine> ();
Details = xr_new<CDetailManager> ();
if (!g_dedicated_server) {
// VB,IB,SWI
// g_pGamePersistent->LoadTitle("st_loading_geometry");
g_pGamePersistent->LoadTitle();
{
CStreamReader *geom = FS.rs_open("$level$","level.geom");
R_ASSERT2 (geom, "level.geom");
LoadBuffers (geom,FALSE);
LoadSWIs (geom);
FS.r_close (geom);
}
//...and alternate/fast geometry
{
CStreamReader *geom = FS.rs_open("$level$","level.geomx");
R_ASSERT2 (geom, "level.geomX");
LoadBuffers (geom,TRUE);
FS.r_close (geom);
}
// Visuals
// g_pGamePersistent->LoadTitle("st_loading_spatial_db");
g_pGamePersistent->LoadTitle();
chunk = fs->open_chunk(fsL_VISUALS);
LoadVisuals (chunk);
chunk->close ();
// Details
// g_pGamePersistent->LoadTitle("st_loading_details");
g_pGamePersistent->LoadTitle();
Details->Load ();
}
// Sectors
// g_pGamePersistent->LoadTitle("st_loading_sectors_portals");
g_pGamePersistent->LoadTitle();
LoadSectors (fs);
// 3D Fluid
Load3DFluid ();
// HOM
HOM.Load ();
// Lights
// pApp->LoadTitle ("Loading lights...");
LoadLights (fs);
// End
pApp->LoadEnd ();
// sanity-clear
lstLODs.clear ();
lstLODgroups.clear ();
mapLOD.clear ();
// signal loaded
b_loaded = TRUE ;
}
void CGameMtlLibrary::Load()
{
string_path name;
if (!FS.exist(name, _game_data_,GAMEMTL_FILENAME)){
Log ("! Can't find game material file: ",name);
return;
}
R_ASSERT (material_pairs.empty());
R_ASSERT (materials.empty());
destructor<IReader> F(FS.r_open(name));
IReader& fs = F();
R_ASSERT(fs.find_chunk(GAMEMTLS_CHUNK_VERSION));
u16 version = fs.r_u16();
if (GAMEMTL_CURRENT_VERSION!=version){
Log ("CGameMtlLibrary: invalid version. Library can't load.");
return;
}
R_ASSERT(fs.find_chunk(GAMEMTLS_CHUNK_AUTOINC));
material_index = fs.r_u32();
material_pair_index = fs.r_u32();
materials.clear ();
material_pairs.clear();
IReader* OBJ = fs.open_chunk(GAMEMTLS_CHUNK_MTLS);
if (OBJ) {
u32 count;
for (IReader* O = OBJ->open_chunk_iterator(count); O; O = OBJ->open_chunk_iterator(count,O)) {
SGameMtl* M = new SGameMtl();
M->Load (*O);
materials.push_back(M);
}
OBJ->close ();
}
OBJ = fs.open_chunk(GAMEMTLS_CHUNK_MTLS_PAIR);
if (OBJ){
u32 count;
for (IReader* O = OBJ->open_chunk_iterator(count); O; O = OBJ->open_chunk_iterator(count,O)) {
SGameMtlPair* M = new SGameMtlPair(this);
M->Load (*O);
material_pairs.push_back(M);
}
OBJ->close ();
}
#ifndef _EDITOR
material_count = (u32)materials.size();
material_pairs_rt.resize(material_count*material_count,0);
for (GameMtlPairIt p_it=material_pairs.begin(); material_pairs.end() != p_it; ++p_it){
SGameMtlPair* S = *p_it;
int idx0 = GetMaterialIdx(S->mtl0)*material_count+GetMaterialIdx(S->mtl1);
int idx1 = GetMaterialIdx(S->mtl1)*material_count+GetMaterialIdx(S->mtl0);
material_pairs_rt[idx0]=S;
material_pairs_rt[idx1]=S;
}
#endif
/*
for (GameMtlPairIt p_it=material_pairs.begin(); material_pairs.end() != p_it; ++p_it){
SGameMtlPair* S = *p_it;
for (int k=0; k<S->StepSounds.size(); k++){
Msg("%40s - 0x%x", S->StepSounds[k].handle->file_name(), S->StepSounds[k].g_type);
}
}
*/
}
void CRender::LoadSectors(IReader* fs)
{
// allocate memory for portals
u32 size = fs->find_chunk(fsL_PORTALS);
R_ASSERT(0==size%sizeof(b_portal));
u32 count = size/sizeof(b_portal);
Portals.resize (count);
for (u32 c=0; c<count; c++)
Portals[c] = xr_new<CPortal> ();
// load sectors
IReader* S = fs->open_chunk(fsL_SECTORS);
for (u32 i=0; ; i++)
{
IReader* P = S->open_chunk(i);
if (0==P) break;
CSector* __S = xr_new<CSector> ();
__S->load (*P);
Sectors.push_back (__S);
P->close();
}
S->close();
// load portals
if (count)
{
CDB::Collector CL;
fs->find_chunk (fsL_PORTALS);
for (i=0; i<count; i++)
{
b_portal P;
fs->r (&P,sizeof(P));
CPortal* __P = (CPortal*)Portals[i];
__P->Setup (P.vertices.begin(),P.vertices.size(),
(CSector*)getSector(P.sector_front),
(CSector*)getSector(P.sector_back));
for (u32 j=2; j<P.vertices.size(); j++)
CL.add_face_packed_D(
P.vertices[0],P.vertices[j-1],P.vertices[j],
u32(i)
);
}
if (CL.getTS()<2)
{
Fvector v1,v2,v3;
v1.set (-20000.f,-20000.f,-20000.f);
v2.set (-20001.f,-20001.f,-20001.f);
v3.set (-20002.f,-20002.f,-20002.f);
CL.add_face_packed_D (v1,v2,v3,0);
}
// build portal model
rmPortals = xr_new<CDB::MODEL> ();
rmPortals->build (CL.getV(),int(CL.getVS()),CL.getT(),int(CL.getTS()));
} else {
rmPortals = 0;
}
// debug
// for (int d=0; d<Sectors.size(); d++)
// Sectors[d]->DebugDump ();
pLastSector = 0;
}
void xrLoad(LPCSTR name, bool draft_mode)
{
FS.get_path ("$level$")->_set ((LPSTR)name);
string256 N;
if (!draft_mode) {
// shaders
string_path N;
FS.update_path (N,"$game_data$","shaders_xrlc.xr");
g_shaders_xrlc = xr_new<Shader_xrLC_LIB> ();
g_shaders_xrlc->Load (N);
// Load CFORM
{
strconcat (sizeof(N),N,name,"build.cform");
IReader* fs = FS.r_open(N);
R_ASSERT (fs->find_chunk(0));
hdrCFORM H;
fs->r (&H,sizeof(hdrCFORM));
R_ASSERT (CFORM_CURRENT_VERSION==H.version);
Fvector* verts = (Fvector*)fs->pointer();
CDB::TRI* tris = (CDB::TRI*)(verts+H.vertcount);
Level.build ( verts, H.vertcount, tris, H.facecount );
Level.syncronize ();
Msg("* Level CFORM: %dK",Level.memory()/1024);
g_rc_faces.resize (H.facecount);
R_ASSERT(fs->find_chunk(1));
fs->r (&*g_rc_faces.begin(),g_rc_faces.size()*sizeof(b_rc_face));
LevelBB.set (H.aabb);
FS.r_close (fs);
}
// Load level data
{
strconcat (sizeof(N),N,name,"build.prj");
IReader* fs = FS.r_open (N);
IReader* F;
// Version
u32 version;
fs->r_chunk (EB_Version,&version);
R_ASSERT (XRCL_CURRENT_VERSION >= 17);
R_ASSERT (XRCL_CURRENT_VERSION <= 18);
// Header
b_params Params;
fs->r_chunk (EB_Parameters,&Params);
// Load level data
transfer("materials", g_materials, *fs, EB_Materials);
transfer("shaders_xrlc",g_shader_compile, *fs, EB_Shaders_Compile);
// process textures
Status ("Processing textures...");
{
Surface_Init ();
F = fs->open_chunk (EB_Textures);
u32 tex_count = F->length()/sizeof(b_texture);
for (u32 t=0; t<tex_count; t++)
{
Progress (float(t)/float(tex_count));
b_texture TEX;
F->r (&TEX,sizeof(TEX));
b_BuildTexture BT;
CopyMemory (&BT,&TEX,sizeof(TEX));
// load thumbnail
string128 &N = BT.name;
LPSTR extension = strext(N);
if (extension)
*extension = 0;
xr_strlwr (N);
if (0==xr_strcmp(N,"level_lods")) {
// HACK for merged lod textures
BT.dwWidth = 1024;
BT.dwHeight = 1024;
BT.bHasAlpha= TRUE;
BT.pSurface = 0;
} else {
xr_strcat (N,".thm");
IReader* THM = FS.r_open("$game_textures$",N);
// if (!THM) continue;
R_ASSERT2 (THM, N);
// version
u32 version = 0;
R_ASSERT (THM->r_chunk(THM_CHUNK_VERSION,&version));
// if( version!=THM_CURRENT_VERSION ) FATAL ("Unsupported version of THM file.");
// analyze thumbnail information
R_ASSERT(THM->find_chunk(THM_CHUNK_TEXTUREPARAM));
THM->r (&BT.THM.fmt,sizeof(STextureParams::ETFormat));
BT.THM.flags.assign (THM->r_u32());
BT.THM.border_color = THM->r_u32();
BT.THM.fade_color = THM->r_u32();
BT.THM.fade_amount = THM->r_u32();
BT.THM.mip_filter = THM->r_u32();
BT.THM.width = THM->r_u32();
BT.THM.height = THM->r_u32();
BOOL bLOD=FALSE;
if (N[0]=='l' && N[1]=='o' && N[2]=='d' && N[3]=='\\') bLOD = TRUE;
// load surface if it has an alpha channel or has "implicit lighting" flag
BT.dwWidth = BT.THM.width;
BT.dwHeight = BT.THM.height;
BT.bHasAlpha = BT.THM.HasAlphaChannel();
BT.pSurface = 0;
if (!bLOD)
{
if (BT.bHasAlpha || BT.THM.flags.test(STextureParams::flImplicitLighted))
{
clMsg ("- loading: %s",N);
u32 w=0, h=0;
BT.pSurface = Surface_Load(N,w,h);
R_ASSERT2 (BT.pSurface,"Can't load surface");
if ((w != BT.dwWidth) || (h != BT.dwHeight))
Msg ("! THM doesn't correspond to the texture: %dx%d -> %dx%d", BT.dwWidth, BT.dwHeight, w, h);
BT.Vflip ();
} else {
// Free surface memory
}
}
}
// save all the stuff we've created
g_textures.push_back (BT);
}
}
}
}
// // Load emitters
// {
// strconcat (N,name,"level.game");
// IReader *F = FS.r_open(N);
// IReader *O = 0;
// if (0!=(O = F->open_chunk (AIPOINT_CHUNK))) {
// for (int id=0; O->find_chunk(id); id++) {
// Emitters.push_back(Fvector());
// O->r_fvector3 (Emitters.back());
// }
// O->close();
// }
// }
//
// Load lights
{
strconcat (sizeof(N),N,name,"build.prj");
IReader* F = FS.r_open(N);
R_ASSERT2 (F,"There is no file 'build.prj'!");
IReader &fs= *F;
// Version
u32 version;
fs.r_chunk (EB_Version,&version);
R_ASSERT (XRCL_CURRENT_VERSION >= 17);
R_ASSERT (XRCL_CURRENT_VERSION <= 18);
// Header
b_params Params;
fs.r_chunk (EB_Parameters,&Params);
// Lights (Static)
{
F = fs.open_chunk(EB_Light_static);
b_light_static temp;
u32 cnt = F->length()/sizeof(temp);
for (u32 i=0; i<cnt; i++)
{
R_Light RL;
F->r (&temp,sizeof(temp));
Flight& L = temp.data;
if (_abs(L.range) > 10000.f) {
Msg ("! BAD light range : %f",L.range);
L.range = L.range > 0.f ? 10000.f : -10000.f;
}
// type
if (L.type == D3DLIGHT_DIRECTIONAL) RL.type = LT_DIRECT;
else RL.type = LT_POINT;
// generic properties
RL.position.set (L.position);
RL.direction.normalize_safe (L.direction);
RL.range = L.range*1.1f;
RL.range2 = RL.range*RL.range;
RL.attenuation0 = L.attenuation0;
RL.attenuation1 = L.attenuation1;
RL.attenuation2 = L.attenuation2;
RL.amount = L.diffuse.magnitude_rgb ();
RL.tri[0].set (0,0,0);
RL.tri[1].set (0,0,0);
RL.tri[2].set (0,0,0);
// place into layer
if (0==temp.controller_ID) g_lights.push_back (RL);
}
F->close ();
}
}
// Init params
// g_params.Init ();
// Load initial map from the Level Editor
{
string_path file_name;
strconcat (sizeof(file_name),file_name,name,"build.aimap");
IReader *F = FS.r_open(file_name);
R_ASSERT2 (F, file_name);
R_ASSERT (F->open_chunk(E_AIMAP_CHUNK_VERSION));
R_ASSERT (F->r_u16() == E_AIMAP_VERSION);
R_ASSERT (F->open_chunk(E_AIMAP_CHUNK_BOX));
F->r (&LevelBB,sizeof(LevelBB));
R_ASSERT (F->open_chunk(E_AIMAP_CHUNK_PARAMS));
F->r (&g_params,sizeof(g_params));
R_ASSERT (F->open_chunk(E_AIMAP_CHUNK_NODES));
u32 N = F->r_u32();
R_ASSERT2 (N < ((u32(1) << u32(MAX_NODE_BIT_COUNT)) - 2),"Too many nodes!");
g_nodes.resize (N);
hdrNODES H;
H.version = XRAI_CURRENT_VERSION;
H.count = N+1;
H.size = g_params.fPatchSize;
H.size_y = 1.f;
H.aabb = LevelBB;
typedef BYTE NodeLink[3];
for (u32 i=0; i<N; i++) {
NodeLink id;
u16 pl;
SNodePositionOld _np;
NodePosition np;
for (int j=0; j<4; ++j) {
F->r (&id,3);
g_nodes[i].n[j] = (*LPDWORD(&id)) & 0x00ffffff;
}
pl = F->r_u16();
pvDecompress (g_nodes[i].Plane.n,pl);
F->r (&_np,sizeof(_np));
CNodePositionConverter(_np,H,np);
g_nodes[i].Pos = vertex_position(np,LevelBB,g_params);
g_nodes[i].Plane.build(g_nodes[i].Pos,g_nodes[i].Plane.n);
}
F->close ();
if (!strstr(Core.Params,"-keep_temp_files"))
DeleteFile (file_name);
}
}
