void save_cross_table (IWriter &stream)
{
stream.w_u32 (m_cross_table.size() + sizeof(u32));
m_cross_table.seek (0);
stream.w (m_cross_table.pointer(),m_cross_table.size());
m_cross_table.clear ();
}
bool CEditableObject::SaveSMotions(const char* fname)
{
CMemoryWriter F;
F.w_u32 (m_SMotions.size());
for (SMotionIt m_it=m_SMotions.begin(); m_it!=m_SMotions.end(); m_it++) (*m_it)->Save(F);
return F.save_to(fname);
}
void CALifeStorageManager::save (LPCSTR save_name_no_check, bool update_name)
{
LPCSTR game_saves_path = FS.get_path("$game_saves$")->m_Path;
string_path save_name;
strncpy_s (save_name, sizeof(save_name), save_name_no_check, sizeof(save_name)-5-xr_strlen(SAVE_EXTENSION)-xr_strlen(game_saves_path));
xr_strcpy (g_last_saved_game, save_name);
string_path save;
xr_strcpy (save,m_save_name);
if (save_name)
{
strconcat (sizeof(m_save_name), m_save_name, save_name, SAVE_EXTENSION);
}
else {
if (!xr_strlen(m_save_name)) {
Log ("There is no file name specified!");
return;
}
}
u32 source_count;
u32 dest_count;
void *dest_data;
{
CMemoryWriter stream;
header().save (stream);
time_manager().save (stream);
spawns().save (stream);
objects().save (stream);
registry().save (stream);
source_count = stream.tell();
void *source_data = stream.pointer();
dest_count = rtc_csize(source_count);
dest_data = xr_malloc(dest_count);
dest_count = rtc_compress(dest_data,dest_count,source_data,source_count);
}
string_path temp;
FS.update_path (temp,"$game_saves$",m_save_name);
IWriter *writer = FS.w_open(temp);
writer->w_u32 (u32(-1));
writer->w_u32 (ALIFE_VERSION);
writer->w_u32 (source_count);
writer->w (dest_data,dest_count);
xr_free (dest_data);
FS.w_close (writer);
#ifdef DEBUG
Msg ("* Game %s is successfully saved to file '%s' (%d bytes compressed to %d)",m_save_name,temp,source_count,dest_count + 4);
#else // DEBUG
Msg ("* Game %s is successfully saved to file '%s'",m_save_name,temp);
#endif // DEBUG
if (!update_name)
xr_strcpy (m_save_name,save);
}
//------------------------------------------------------------------------------
bool CEditableObject::ExportOMF(LPCSTR fn)
{
CMemoryWriter F;
if (PrepareOMF(F)){
return F.save_to(fn);
}
return false;
}
bool CEditableObject::ExportOGF(LPCSTR fn, u8 infl)
{
CMemoryWriter F;
if (PrepareOGF(F,infl,true,NULL)){
return F.save_to(fn);
}
return false;
}
void COMotion::SaveMotion(const char* buf){
CMemoryWriter F;
F.open_chunk (EOBJ_OMOTION);
Save (F);
F.close_chunk ();
if (!F.save_to(buf))
Log ("!Can't save object motion:",buf);
}
//------------------------------------------------------------------------------
bool CEditableObject::ExportOBJ(LPCSTR fn)
{
CExportObjectOGF E(this);
CMemoryWriter F;
if (E.ExportAsWavefrontOBJ(F,fn)){
return F.save_to(fn);
}
return false;
}
void __fastcall TfrmText::ebSaveClick(TObject *Sender)
{
xr_string fn;
if (EFS.GetSaveName(_import_,fn,NULL,2)){
CMemoryWriter F;
F.w_stringZ (mmText->Text.c_str());
if (!F.save_to(fn.c_str()))
Log ("!Can't save text file:",fn.c_str());
}
}
void CBuild::SaveTREE (IWriter &fs)
{
CMemoryWriter MFS;
Status ("Geometry buffers...");
xr_vector<u32> remap;
remap.reserve (g_tree.size());
for (u32 rid=0; rid<g_tree.size(); rid++) {
OGF* o = dynamic_cast<OGF*> (g_tree[rid]);
if (o) remap.push_back(rid);
}
std::stable_sort (remap.begin(),remap.end(),remap_order);
clMsg ("remap-size: %d / %d",remap.size(),g_tree.size());
for (u32 sid=0; sid<remap.size(); sid++) {
u32 id = remap[sid];
//clMsg ("%3d: subdiv: %d",sid,id);
g_tree[id]->PreSave (id);
}
Status ("Visuals...");
fs.open_chunk (fsL_VISUALS);
for (xr_vector<OGF_Base*>::iterator it = g_tree.begin(); it!=g_tree.end(); it++) {
u32 idx = u32(it-g_tree.begin());
MFS.open_chunk (idx);
(*it)->Save (MFS);
MFS.close_chunk ();
Progress (float(idx)/float(g_tree.size()));
}
fs.w (MFS.pointer(),MFS.size());
fs.close_chunk ();
clMsg ("Average: %d verts/%d faces, 50(%2.1f), 100(%2.1f), 500(%2.1f), 1000(%2.1f), 5000(%2.1f)",
g_batch_verts/g_batch_count,
g_batch_faces/g_batch_count,
100.f * float(g_batch_50)/float(g_batch_count),
100.f * float(g_batch_100)/float(g_batch_count),
100.f * float(g_batch_500)/float(g_batch_count),
100.f * float(g_batch_1000)/float(g_batch_count),
100.f * float(g_batch_5000)/float(g_batch_count)
);
mem_Compact ();
SaveGEOMs ("level.geom", g_VB,g_IB,g_SWI); // Normal
SaveGEOMs ("level.geomx", x_VB,x_IB,x_SWI); // Fast-Path
Status ("Shader table...");
fs.open_chunk (fsL_SHADERS);
fs.w_u32 (g_Shaders.size());
for (xr_vector<LPCSTR>::iterator T=g_Shaders.begin(); T!=g_Shaders.end(); T++)
fs.w_stringZ (*T);
fs.close_chunk ();
//mem_Compact ();
}
void CGameGraphBuilder::save_cross_table (const float &start, const float &amount)
{
Progress (start);
Msg ("Saving cross table");
// CTimer timer;
// timer.Start ();
CMemoryWriter tMemoryStream;
CGameLevelCrossTable::CHeader tCrossTableHeader;
tCrossTableHeader.dwVersion = XRAI_CURRENT_VERSION;
tCrossTableHeader.dwNodeCount = level_graph().header().vertex_count();
tCrossTableHeader.dwGraphPointCount = graph().header().vertex_count();
tCrossTableHeader.m_level_guid = level_graph().header().guid();
tCrossTableHeader.m_game_guid = m_graph_guid;
tMemoryStream.open_chunk (CROSS_TABLE_CHUNK_VERSION);
tMemoryStream.w (&tCrossTableHeader,sizeof(tCrossTableHeader));
tMemoryStream.close_chunk ();
tMemoryStream.open_chunk (CROSS_TABLE_CHUNK_DATA);
for (int i=0, n=level_graph().header().vertex_count(); i<n; i++) {
CGameLevelCrossTable::CCell tCrossTableCell;
tCrossTableCell.tGraphIndex = (GameGraph::_GRAPH_ID)m_results[i];
VERIFY (graph().header().vertex_count() > tCrossTableCell.tGraphIndex);
tCrossTableCell.fDistance = float(m_distances[tCrossTableCell.tGraphIndex][i])*level_graph().header().cell_size();
tMemoryStream.w (&tCrossTableCell,sizeof(tCrossTableCell));
}
tMemoryStream.close_chunk();
// Msg ("CT:SAVE : %f",timer.GetElapsed_sec());
// Msg ("Flushing cross table");
#ifdef PRIQUEL
tMemoryStream.save_to (m_cross_table_name);
#else // PRIQUEL
string_path file_name;
strconcat (sizeof(file_name), file_name,*m_level_name,CROSS_TABLE_NAME_RAW);
tMemoryStream.save_to (file_name);
#endif // PRIQUEL
// Msg ("CT:SAVE : %f",timer.GetElapsed_sec());
// Msg ("Freiing cross table resources");
m_marks.clear ();
m_mark_stack.clear ();
m_distances.clear ();
m_current_fringe.clear ();
m_next_fringe.clear ();
// Msg ("CT:SAVE : %f",timer.GetElapsed_sec());
Progress (start + amount);
}
void ETextureThumbnail::Save(int age, LPCSTR path)
{
if (!Valid()) return;
CMemoryWriter F;
F.open_chunk (THM_CHUNK_VERSION);
F.w_u16 (THM_TEXTURE_VERSION);
F.close_chunk ();
/*
F.w_chunk (THM_CHUNK_DATA | CFS_CompressMark,m_Pixels.begin(),m_Pixels.size()*sizeof(u32));
*/
F.open_chunk (THM_CHUNK_TYPE);
F.w_u32 (m_Type);
F.close_chunk ();
m_TexParams.Save(F);
string_path fn;
if (path)
FS.update_path(fn, path, m_Name.c_str());
else
FS.update_path(fn, _game_textures_, m_Name.c_str());
if (F.save_to(fn))
{
FS.set_file_age (fn,age?age:m_Age);
}else{
Log ("!Can't save thumbnail:",fn);
}
}
void OpenPack (LPCSTR tgt_folder, int num)
{
VERIFY (0==fs);
string_path fname;
string128 s_num;
#ifdef MOD_COMPRESS
strconcat (sizeof(fname),fname,tgt_folder,".xdb",itoa(num,s_num,10));
#else
strconcat (sizeof(fname),fname,tgt_folder,".pack_#",itoa(num,s_num,10));
#endif
unlink (fname);
fs = FS.w_open (fname);
fs_desc.clear ();
aliases.clear ();
bytesSRC = 0;
bytesDST = 0;
filesTOTAL = 0;
filesSKIP = 0;
filesVFS = 0;
filesALIAS = 0;
dwTimeStart = timeGetTime();
fs->open_chunk (0);
}
void vfSaveVertices(CMemoryWriter &tMemoryStream, u32 &dwOffset, u32 &dwPointOffset, LEVEL_POINT_STORAGE *tpLevelPoints)
{
GRAPH_VERTEX_IT I = m_tpVertices.begin();
GRAPH_VERTEX_IT E = m_tpVertices.end();
GameGraph::CVertex tVertex;
for ( ; I != E; I++) {
tVertex.tLocalPoint = (*I).tLocalPoint;
tVertex.tGlobalPoint = (*I).tGlobalPoint;
tVertex.tNodeID = (*I).tNodeID;
Memory.mem_copy (tVertex.tVertexTypes,(*I).tVertexTypes,GameGraph::LOCATION_TYPE_COUNT*sizeof(GameGraph::_LOCATION_ID));
tVertex.tLevelID = (*I).tLevelID;
tVertex.dwEdgeOffset = dwOffset;
tVertex.dwPointOffset = dwPointOffset;
VERIFY ((*I).tNeighbourCount < (u32(1) << (8*sizeof(u8))));
tVertex.tNeighbourCount = (u8)(*I).tNeighbourCount;
VERIFY ((*I).tDeathPointCount < (u32(1) << (8*sizeof(u8))));
tVertex.tDeathPointCount= (u8)(*I).tDeathPointCount;
tMemoryStream.w (&tVertex,sizeof(tVertex));
dwOffset += (*I).tNeighbourCount*sizeof(CGameGraph::CEdge);
dwPointOffset += (*I).tDeathPointCount*sizeof(CGameGraph::CLevelPoint);
}
};
void vfSaveEdges(CMemoryWriter &tMemoryStream)
{
GRAPH_VERTEX_IT I = m_tpVertices.begin();
GRAPH_VERTEX_IT E = m_tpVertices.end();
for ( ; I != E; I++)
for (int i=0; i<(int)(*I).tNeighbourCount; i++)
tMemoryStream.w ((*I).tpaEdges + i,sizeof(CGameGraph::CEdge));
};
void CBuild::SaveSectors(IWriter& fs)
{
CMemoryWriter MFS;
Status("Processing...");
// validate & save
for (u32 I=0; I<g_sectors.size(); I++)
{
MFS.open_chunk(I);
g_sectors[I]->Validate();
g_sectors[I]->Save(MFS);
MFS.close_chunk();
Progress(float(I)/float(g_sectors.size()));
}
fs.w_chunk(fsL_SECTORS,MFS.pointer(),MFS.size());
}
//----------------------------------------------------
// some types
bool SceneBuilder::BuildHOMModel()
{
CMemoryWriter F;
F.open_chunk(0);
F.w_u32(0);
F.close_chunk();
F.open_chunk(1);
ObjectList& lst = Scene->ListObj(OBJCLASS_SCENEOBJECT);
for (ObjectIt it=lst.begin(); it!=lst.end(); it++){
CSceneObject* S = (CSceneObject*)(*it);
CEditableObject* E = S->GetReference(); R_ASSERT(E);
if (E->m_Flags.is(CEditableObject::eoHOM)){
Fvector v;
const Fmatrix& parent = S->_Transform();
for (EditMeshIt m_it=E->FirstMesh(); m_it!=E->LastMesh(); m_it++){
for (SurfFacesPairIt sf_it=(*m_it)->m_SurfFaces.begin(); sf_it!=(*m_it)->m_SurfFaces.end(); sf_it++){
BOOL b2Sided = sf_it->first->m_Flags.is(CSurface::sf2Sided);
IntVec& i_lst= sf_it->second;
for (IntIt i_it=i_lst.begin(); i_it!=i_lst.end(); i_it++){
st_Face& face = (*m_it)->m_Faces[*i_it];
for (int k=0; k<3; k++){
parent.transform_tiny(v,(*m_it)->m_Verts[face.pv[k].pindex]);
F.w_fvector3 (v);
}
F.w_u32(b2Sided);
}
}
}
}
}
BOOL bValid = !!F.chunk_size();
F.close_chunk();
if (bValid){
xr_string hom_name = MakeLevelPath("level.hom");
bValid = F.save_to(hom_name.c_str());
}
return bValid;
}
void CSoundManager::MakeGameSound(ESoundThumbnail* THM, LPCSTR src_name, LPCSTR game_name)
{
VerifyPath(game_name);
CMemoryWriter F;
F.w_u32 (OGG_COMMENT_VERSION);
F.w_float (THM->m_fMinDist);
F.w_float (THM->m_fMaxDist);
F.w_float (THM->m_fBaseVolume);
F.w_u32 (THM->m_uGameType);
F.w_float (THM->m_fMaxAIDist);
if (!ogg_enc(src_name,game_name, THM->m_fQuality,F.pointer(),F.size())){
FS.file_delete(game_name);
ELog.DlgMsg(mtError,"Can't make game sound '%s'.",game_name);
}
}
bool weather::save_time_frame (shared_str const& frame_id, char* buffer, u32 const& buffer_size)
{
container_type::iterator i = m_times.begin();
container_type::iterator e = m_times.end();
for ( ; i != e; ++i) {
if (frame_id._get() != (*i)->id()._get())
continue;
CInifile temp(0, FALSE, FALSE, FALSE);
(*i)->save (temp);
CMemoryWriter writer;
temp.save_as (writer);
if (writer.size() > buffer_size)
return (false);
writer.seek (0);
Memory.mem_copy (buffer, writer.pointer(), writer.size());
return (true);
}
return (false);
}
IC void write_file_header (LPCSTR file_name, const u32 &crc, const u32 &ptr, const u32 &size_real, const u32 &size_compressed)
{
#ifndef PROTECTED_BUILD
fs_desc.w_stringZ (file_name);
fs_desc.w_u32 (crc); // crc
fs_desc.w_u32 (ptr);
fs_desc.w_u32 (size_real);
fs_desc.w_u32 (size_compressed);
#else // PROTECTED_BUILD
u32 file_name_size = (xr_strlen(file_name) + 0)*sizeof(char);
u32 buffer_size = file_name_size + 4*sizeof(u32);
VERIFY (buffer_size <= 65535);
u32 full_buffer_size = buffer_size + sizeof(u16);
u8 *buffer = (u8*)_alloca(full_buffer_size);
u8 *buffer_start = buffer;
*(u16*)buffer = (u16)buffer_size;
buffer += sizeof(u16);
*(u32*)buffer = size_real;
buffer += sizeof(u32);
*(u32*)buffer = size_compressed;
buffer += sizeof(u32);
*(u32*)buffer = crc;
buffer += sizeof(u32);
Memory.mem_copy (buffer,file_name,file_name_size);
buffer += file_name_size;
*(u32*)buffer = ptr;
// trivial_encryptor::encode (buffer_start,full_buffer_size,buffer_start);
fs_desc.w (buffer_start,full_buffer_size);
#endif // PROTECTED_BUILD
}
void ClosePack ()
{
fs->close_chunk ();
// save list
bytesDST = fs->tell ();
Log ("...Writing pack desc");
#ifdef MOD_COMPRESS
DUMMY_STUFF* _dummy_stuff_tmp;
_dummy_stuff_tmp = g_dummy_stuff;
g_dummy_stuff = NULL;
#endif
fs->w_chunk (1|CFS_CompressMark, fs_desc.pointer(),fs_desc.size());
#ifdef MOD_COMPRESS
g_dummy_stuff = _dummy_stuff_tmp;
#endif
Msg ("Data size: %d. Desc size: %d.",bytesDST,fs_desc.size());
FS.w_close (fs);
Log ("Pack saved.");
u32 dwTimeEnd = timeGetTime();
printf ("\n\nFiles total/skipped/VFS/aliased: %d/%d/%d/%d\nOveral: %dK/%dK, %3.1f%%\nElapsed time: %d:%d\nCompression speed: %3.1f Mb/s",
filesTOTAL,filesSKIP,filesVFS,filesALIAS,
bytesDST/1024,bytesSRC/1024,
100.f*float(bytesDST)/float(bytesSRC),
((dwTimeEnd-dwTimeStart)/1000)/60,
((dwTimeEnd-dwTimeStart)/1000)%60,
float((float(bytesDST)/float(1024*1024))/(t_compress.GetElapsed_sec()))
);
Msg ("\n\nFiles total/skipped/VFS/aliased: %d/%d/%d/%d\nOveral: %dK/%dK, %3.1f%%\nElapsed time: %d:%d\nCompression speed: %3.1f Mb/s\n\n",
filesTOTAL,filesSKIP,filesVFS,filesALIAS,
bytesDST/1024,bytesSRC/1024,
100.f*float(bytesDST)/float(bytesSRC),
((dwTimeEnd-dwTimeStart)/1000)/60,
((dwTimeEnd-dwTimeStart)/1000)%60,
float((float(bytesDST)/float(1024*1024))/(t_compress.GetElapsed_sec()))
);
}
void ELightAnimLibrary::Save()
{
CMemoryWriter F;
F.open_chunk (CHUNK_VERSION);
F.w_u16 (LANIM_VERSION);
F.close_chunk ();
F.open_chunk (CHUNK_ITEM_LIST);
int count = 0;
for (LAItemIt it=Items.begin(); it!=Items.end(); it++){
F.open_chunk(count++);
(*it)->Save (F);
F.close_chunk();
}
F.close_chunk ();
string_path fn;
FS.update_path (fn,_game_data_,"lanims.xr");
if (!F.save_to(fn))
Log ("!Can't save color animations:",fn);
}
bool manager::save_current_blend(char* buffer, u32 const& buffer_size)
{
CInifile temp(0, FALSE, FALSE, FALSE);
using editor::environment::weathers::time;
time* frame = static_cast<time*>(m_manager.CurrentEnv);
frame->save(temp);
CMemoryWriter writer;
temp.save_as(writer);
if (writer.size() > buffer_size)
return (false);
writer.w_u8(0);
writer.seek(0);
Memory.mem_copy(buffer, writer.pointer(), writer.size());
return (true);
}
void CLevel::net_Save (LPCSTR name) // Game Save
{
if (0==Server) {
Msg("KERNEL::Can't save game on pure client");
return;
}
// 1. Create stream
CMemoryWriter fs;
// 2. Description
fs.open_chunk (fsSLS_Description);
fs.w_stringZ (net_SessionName());
fs.close_chunk ();
// 3. Server state
fs.open_chunk (fsSLS_ServerState);
Server->SLS_Save (fs);
fs.close_chunk ();
// Save it to file
fs.save_to (name);
}
void CGameGraphBuilder::save_graph (const float &start, const float &amount)
{
Progress (start);
Msg ("Saving graph");
// header
CMemoryWriter writer;
CGameGraph::CHeader header;
header.m_version = XRAI_CURRENT_VERSION;
VERIFY (graph().vertices().size() < (u32(1) << (8*sizeof(GameGraph::_GRAPH_ID))));
header.m_vertex_count = (GameGraph::_GRAPH_ID)graph().vertices().size();
VERIFY (graph().edge_count() < (u32(1) << (8*sizeof(GameGraph::_GRAPH_ID))));
header.m_edge_count = (GameGraph::_GRAPH_ID)graph().edge_count();
header.m_death_point_count = 0;
header.m_guid = m_graph_guid;
// levels
CGameGraph::SLevel level;
level.m_offset.set (0,0,0);
level.m_id = 0;
level.m_name = m_level_name;
level.m_section = "";
level.m_guid = level_graph().header().guid();
header.m_levels.insert (std::make_pair(level.m_id,level));
header.save (&writer);
{
u32 edge_offset = graph().vertices().size()*sizeof(CGameGraph::CVertex);
graph_type::const_vertex_iterator I = graph().vertices().begin();
graph_type::const_vertex_iterator E = graph().vertices().end();
for ( ; I != E; ++I) {
CGameGraph::CVertex &vertex = (*I).second->data();
VERIFY ((*I).second->edges().size() < 256);
vertex.tNeighbourCount = (u8)(*I).second->edges().size();
vertex.dwEdgeOffset = edge_offset;
edge_offset += vertex.tNeighbourCount*sizeof(CGameGraph::CEdge);
writer.w (&vertex,sizeof(CGameGraph::CVertex));
}
}
{
graph_type::const_vertex_iterator I = graph().vertices().begin();
graph_type::const_vertex_iterator E = graph().vertices().end();
for ( ; I != E; ++I) {
graph_type::const_iterator i = (*I).second->edges().begin();
graph_type::const_iterator e = (*I).second->edges().end();
for ( ; i != e; ++i) {
GameGraph::CEdge edge;
VERIFY ((*i).vertex_id() < (u32(1) << (8*sizeof(GameGraph::_GRAPH_ID))));
edge.m_vertex_id = (GameGraph::_GRAPH_ID)(*i).vertex_id();
edge.m_path_distance = (*i).weight();
writer.w (&edge.m_vertex_id,sizeof(edge.m_vertex_id));
writer.w_float (edge.m_path_distance);
}
}
}
#ifdef PRIQUEL
writer.save_to (m_graph_name);
#else // PRIQUEL
string_path file_name;
strconcat (sizeof(file_name),file_name,*m_level_name,GAME_LEVEL_GRAPH);
writer.save_to (file_name);
#endif // PRIQUEL
Msg ("%d bytes saved",int(writer.size()));
Progress (start + amount);
}
BOOL SceneBuilder::BuildGame()
{
SExportStreams F;
F.envmodif.stream.open_chunk (F.envmodif.chunk++);
F.envmodif.stream.w_u32 (u32(SPAWNPOINT_VERSION));
F.envmodif.stream.close_chunk ();
if (!Scene->ExportGame(&F)) return FALSE;
BOOL bRes = TRUE;
// save spawn
{
xr_string lev_spawn = MakeLevelPath("level.spawn");
EFS.MarkFile (lev_spawn.c_str(),true);
if (F.spawn.chunk)
if (!F.spawn.stream.save_to (lev_spawn.c_str())) bRes = FALSE;
lev_spawn = MakeLevelPath("level_rs.spawn");
EFS.MarkFile (lev_spawn.c_str(),true);
if (F.spawn_rs.chunk)
if (!F.spawn_rs.stream.save_to (lev_spawn.c_str())) bRes = FALSE;
}
// save game
{
CMemoryWriter GAME;
GAME.w_chunk(WAY_PATROLPATH_CHUNK, F.patrolpath.stream.pointer(), F.patrolpath.stream.size());
GAME.w_chunk(RPOINT_CHUNK, F.rpoint.stream.pointer(), F.rpoint.stream.size());
xr_string lev_game = MakeLevelPath("level.game");
EFS.MarkFile (lev_game.c_str(),true);
if (GAME.size())
if (!GAME.save_to (lev_game.c_str())) bRes = FALSE;
}
// save weather env modificator
{
xr_string lev_env_mod = MakeLevelPath("level.env_mod");
EFS.MarkFile (lev_env_mod.c_str(),true);
if (F.envmodif.chunk)
if (!F.envmodif.stream.save_to (lev_env_mod.c_str())) bRes = FALSE;
}
// save static sounds
{
xr_string lev_sound_static = MakeLevelPath("level.snd_static");
EFS.MarkFile (lev_sound_static.c_str(),true);
if (F.sound_static.chunk)
if (!F.sound_static.stream.save_to (lev_sound_static.c_str())) bRes = FALSE;
}
/*
// save sound envs
{
xr_string lev_sound_env = MakeLevelPath("level.snd_env");
EFS.MarkFile (lev_sound_env.c_str(),true);
if (LSndLib->MakeEnvGeometry (F.sound_env_geom.stream,false))
if (!F.sound_env_geom.stream.save_to(lev_sound_env.c_str())) bRes = FALSE;
}
*/
// save static PG
{
xr_string lev_pe_static = MakeLevelPath("level.ps_static");
EFS.MarkFile (lev_pe_static.c_str(),true);
if (F.pe_static.chunk)
if (!F.pe_static.stream.save_to (lev_pe_static.c_str())) bRes = FALSE;
}
// save fog volumes
if(1)
{
xr_string lev_fog_vol = MakeLevelPath("level.fog_vol");
EFS.MarkFile (lev_fog_vol.c_str(),true);
F.fog_vol.stream.w_u16 (3); //version
ObjectList& fogs = Scene->ListObj(OBJCLASS_FOG_VOL);
typedef xr_vector<EFogVolume*> tfog_group;
typedef xr_map<u32, tfog_group> tfog_groups;
tfog_groups fog_groups;
for (ObjectIt oit=fogs.begin(); oit!=fogs.end(); ++oit)
{
EFogVolume* E = dynamic_cast<EFogVolume*>(*oit);
R_ASSERT (E);
u32 grp_id = E->m_group_id;
fog_groups[grp_id].push_back(E);
}
F.fog_vol.stream.w_u32 (fog_groups.size());
tfog_groups::iterator git = fog_groups.begin();
tfog_groups::iterator git_e = fog_groups.end();
for(; git!=git_e; ++git)
{
tfog_group& one_group = git->second;
std::sort(one_group.begin(), one_group.end(), sort_fog_vol);
tfog_group::iterator fgit = one_group.begin();
tfog_group::iterator fgit_e = one_group.end();
for(; fgit!=fgit_e; ++fgit)
{
EFogVolume* E = *fgit;
if(fgit==one_group.begin())
{
if(E->m_volumeType!=fvEmitter)
{
bRes = FALSE;
Msg("! incorrect fog volumes grouping");
break;
}
F.fog_vol.stream.w_string (E->m_volume_profile.c_str());
}
Fmatrix M = E->_Transform();
F.fog_vol.stream.w (&M, sizeof(M));
if(fgit==one_group.begin())
{
if(E->m_volumeType!=fvEmitter)
{
bRes = FALSE;
Msg("! incorrect fog volumes grouping");
break;
}
F.fog_vol.stream.w_u32 (one_group.size()-1);
}else
{
if(E->m_volumeType!=fvOcclusion)
{
bRes = FALSE;
Msg("! incorrect fog volumes grouping");
break;
}
}
if(!bRes)
break;
}
if(!bRes)
break;
}
if (!F.fog_vol.stream.save_to(lev_fog_vol.c_str()))
bRes = FALSE;
}
return bRes;
}
void xrCompressor::OpenPack(LPCSTR tgt_folder, int num)
{
VERIFY (0==fs_pack_writer);
string_path fname;
string128 s_num;
#ifdef MOD_COMPRESS
strconcat (sizeof(fname),fname,tgt_folder,".xdb",itoa(num,s_num,10));
#else
strconcat (sizeof(fname),fname,tgt_folder,".pack_#",itoa(num,s_num,10));
#endif
unlink (fname);
fs_pack_writer = FS.w_open (fname);
fs_desc.clear ();
aliases.clear ();
bytesSRC = 0;
bytesDST = 0;
filesTOTAL = 0;
filesSKIP = 0;
filesVFS = 0;
filesALIAS = 0;
dwTimeStart = timeGetTime();
//write pack header without compression
// DUMMY_STUFF* _dummy_stuff_subst = NULL;
// _dummy_stuff_subst = g_dummy_stuff;
// g_dummy_stuff = NULL;
if(config_ltx && config_ltx->section_exist("header"))
{
CMemoryWriter W;
CInifile::Sect& S = config_ltx->r_section("header");
CInifile::SectCIt it = S.Data.begin();
CInifile::SectCIt it_e = S.Data.end();
string4096 buff;
xr_sprintf (buff,"[%s]",S.Name.c_str());
W.w_string (buff);
for(;it!=it_e;++it)
{
const CInifile::Item& I = *it;
xr_sprintf (buff, "%s = %s", I.first.c_str(), I.second.c_str());
W.w_string (buff);
}
W.seek (0);
IReader R(W.pointer(), W.size());
printf ("...Writing pack header\n");
fs_pack_writer->open_chunk (CFS_HeaderChunkID);
fs_pack_writer->w (R.pointer(), R.length());
fs_pack_writer->close_chunk ();
}else
if(pPackHeader)
{
printf ("...Writing pack header\n");
fs_pack_writer->open_chunk (CFS_HeaderChunkID);
fs_pack_writer->w (pPackHeader->pointer(), pPackHeader->length());
fs_pack_writer->close_chunk ();
}else
printf ("...Pack header not found\n");
// g_dummy_stuff = _dummy_stuff_subst;
fs_pack_writer->open_chunk (0);
}
bool EDetailManager::Export(LPCSTR path)
{
AnsiString fn = AnsiString(path)+"build.details";
bool bRes=true;
SPBItem* pb = UI->ProgressStart(5,"Making details...");
CMemoryWriter F;
pb->Inc ("merge textures");
Fvector2Vec offsets;
Fvector2Vec scales;
boolVec rotated;
RStringSet textures_set;
RStringVec textures;
U32Vec remap;
U8Vec remap_object (objects.size(),u8(-1));
int slot_cnt = dtH.size_x*dtH.size_z;
for (int slot_idx=0; slot_idx<slot_cnt; slot_idx++){
DetailSlot* it = &dtSlots[slot_idx];
for (int part=0; part<4; part++){
u8 id = it->r_id(part);
if (id!=DetailSlot::ID_Empty) {
textures_set.insert(((EDetail*)(objects[id]))->GetTextureName());
remap_object[id] = 1;
}
}
}
textures.assign (textures_set.begin(),textures_set.end());
U8It remap_object_it= remap_object.begin();
u32 new_idx = 0;
for (DetailIt d_it=objects.begin(); d_it!=objects.end(); d_it++,remap_object_it++)
if ((*remap_object_it==1)&&(textures_set.find(((EDetail*)(*d_it))->GetTextureName())!=textures_set.end()))
*remap_object_it = (u8)new_idx++;
AnsiString do_tex_name = ChangeFileExt(fn,"_details");
int res = ImageLib.CreateMergedTexture(textures,do_tex_name.c_str(),STextureParams::tfADXT1,256,1024,256,1024,offsets,scales,rotated,remap);
if (1!=res) bRes=FALSE;
pb->Inc ("export geometry");
// objects
int object_idx = 0;
if (bRes){
do_tex_name = ExtractFileName(do_tex_name);
F.open_chunk (DETMGR_CHUNK_OBJECTS);
for (DetailIt it=objects.begin(); it!=objects.end(); it++){
if (remap_object[it-objects.begin()]!=u8(-1)){
F.open_chunk (object_idx++);
if (!((EDetail*)(*it))->m_pRefs){
ELog.DlgMsg(mtError, "Bad object or object not found '%s'.", ((EDetail*)(*it))->m_sRefs.c_str());
bRes=false;
}else{
LPCSTR tex_name = ((EDetail*)(*it))->GetTextureName();
for (u32 t_idx=0; t_idx<textures.size(); t_idx++)
if (textures[t_idx]==tex_name) break;
VERIFY(t_idx<textures.size());
t_idx = remap[t_idx];
((EDetail*)(*it))->Export (F,do_tex_name.c_str(),offsets[t_idx],scales[t_idx],rotated[t_idx]);
}
F.close_chunk ();
if (!bRes) break;
}
}
F.close_chunk ();
}
pb->Inc ("export slots");
// slots
if (bRes){
xr_vector<DetailSlot> dt_slots(slot_cnt); dt_slots.assign(dtSlots,dtSlots+slot_cnt);
for (slot_idx=0; slot_idx<slot_cnt; slot_idx++){
DetailSlot& it = dt_slots[slot_idx];
// zero colors need lighting
it.c_dir = 0;
it.c_hemi = 0;
it.c_r = 0;
it.c_g = 0;
it.c_b = 0;
for (int part=0; part<4; part++){
u8 id = it.r_id(part);
if (id!=DetailSlot::ID_Empty) it.w_id(part,remap_object[id]);
}
}
F.open_chunk (DETMGR_CHUNK_SLOTS);
F.w (dt_slots.begin(),dtH.size_x*dtH.size_z*sizeof(DetailSlot));
F.close_chunk ();
pb->Inc();
// write header
dtH.version = DETAIL_VERSION;
dtH.object_count= object_idx;
F.w_chunk (DETMGR_CHUNK_HEADER,&dtH,sizeof(DetailHeader));
bRes = F.save_to(fn.c_str());
}
pb->Inc();
UI->ProgressEnd(pb);
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);
}
};
CGraphMerger::CGraphMerger(
LPCSTR game_graph_id,
LPCSTR name,
bool rebuild
)
{
// load all the graphs
Phase("Processing level graphs");
CInifile *Ini = new CInifile(INI_FILE);
if (!Ini->section_exist("levels"))
THROW(false);
R_ASSERT (Ini->section_exist("levels"));
tGraphHeader.m_guid = generate_guid();
GRAPH_P_MAP tpGraphs;
string4096 S1, S2;
CGameGraph::SLevel tLevel;
u32 dwOffset = 0;
u32 l_dwPointOffset = 0;
LEVEL_POINT_STORAGE l_tpLevelPoints;
l_tpLevelPoints.clear ();
xr_set<CLevelInfo> levels;
xr_vector<LPCSTR> needed_levels;
string4096 levels_string;
strcpy_s (levels_string,name);
strlwr (levels_string);
fill_needed_levels (levels_string,needed_levels);
read_levels (
Ini,
levels,
rebuild,
&needed_levels
);
xr_set<CLevelInfo>::const_iterator I = levels.begin();
xr_set<CLevelInfo>::const_iterator E = levels.end();
for ( ; I != E; ++I) {
tLevel.m_offset = (*I).m_offset;
tLevel.m_name = (*I).m_name;
strcpy_s (S1,sizeof(S1),*(*I).m_name);
strconcat (sizeof(S2),S2,name,S1);
strconcat (sizeof(S1),S1,S2,"\\");
tLevel.m_id = (*I).m_id;
tLevel.m_section = (*I).m_section;
Msg ("%9s %2d %s","level",tLevel.id(),*tLevel.m_name);
string_path _0, _1;
generate_temp_file_name ("local_graph_",*tLevel.m_name,_0);
generate_temp_file_name ("raw_cross_table_",*tLevel.m_name,_1);
string_path level_folder;
FS.update_path (level_folder,"$game_levels$",*tLevel.m_name);
strcat (level_folder,"\\");
CGameGraphBuilder().build_graph (_0,_1,level_folder);
::CLevelGameGraph *tpLevelGraph = new ::CLevelGameGraph(
_0,
_1,
&tLevel,
level_folder,
dwOffset,
tLevel.id(),
Ini
);
dwOffset += tpLevelGraph->m_tpGraph->header().vertex_count();
R_ASSERT2 (tpGraphs.find(tLevel.id()) == tpGraphs.end(),"Level ids _MUST_ be different!");
tpGraphs.insert (mk_pair(tLevel.id(),tpLevelGraph));
tGraphHeader.m_levels.insert(std::make_pair(tLevel.id(),tLevel));
}
R_ASSERT(tpGraphs.size());
Phase("Adding interconnection points");
{
GRAPH_P_PAIR_IT I = tpGraphs.begin();
GRAPH_P_PAIR_IT E = tpGraphs.end();
for ( ; I != E; I++) {
VERTEX_PAIR_IT i = (*I).second->m_tVertexMap.begin();
VERTEX_PAIR_IT e = (*I).second->m_tVertexMap.end();
for ( ; i != e; i++)
if ((*i).second.caConnectName[0]) {
GRAPH_P_PAIR_IT K;
VERTEX_PAIR_IT M;
CGameGraph::CEdge tGraphEdge;
SConnectionVertex &tConnectionVertex = (*i).second;
K = tpGraphs.find(tConnectionVertex.dwLevelID);
if (K == tpGraphs.end()) {
Msg ("Cannot find level with level_id %d. Connection point will not be generated!",tConnectionVertex.dwLevelID);
continue;
}
R_ASSERT (K != tpGraphs.end());
M = (*K).second->m_tVertexMap.find(tConnectionVertex.caConnectName);
if (M == (*K).second->m_tVertexMap.end()) {
Msg ("Level %s with id %d has an INVALID connection point %s,\nwhich references to graph point %s on the level %s with id %d\n",*(*I).second->m_tLevel.name(),(*I).second->m_tLevel.id(),(*i).first,tConnectionVertex.caConnectName,*(*K).second->m_tLevel.name(),(*K).second->m_tLevel.id());
R_ASSERT (M != (*K).second->m_tVertexMap.end());
}
// if (!stricmp("l06_rostok",*(*I).second->m_tLevel.name())) {
// __asm int 3;
// }
Msg ("Level %s with id %d has VALID connection point %s,\nwhich references to graph point %s on the level %s with id %d\n",*(*I).second->m_tLevel.name(),(*I).second->m_tLevel.id(),(*i).first,tConnectionVertex.caConnectName,*(*K).second->m_tLevel.name(),(*K).second->m_tLevel.id());
VERIFY (((*M).second.tGraphID + (*K).second->m_dwOffset) < (u32(1) << (8*sizeof(GameGraph::_GRAPH_ID))));
tGraphEdge.m_vertex_id = (GameGraph::_GRAPH_ID)((*M).second.tGraphID + (*K).second->m_dwOffset);
VERIFY3 (tConnectionVertex.tGraphID < (*I).second->m_tpVertices.size(),"Rebuild graph for the level",*(*I).second->m_tLevel.name());
VERIFY3 ((*M).second.tGraphID < (*K).second->m_tpVertices.size(),"Rebuild graph for the level",*(*K).second->m_tLevel.name());
tGraphEdge.m_path_distance = (*I).second->m_tpVertices[tConnectionVertex.tGraphID].tGlobalPoint.distance_to((*K).second->m_tpVertices[(*M).second.tGraphID].tGlobalPoint);
(*I).second->vfAddEdge ((*i).second.tGraphID,tGraphEdge);
// tGraphEdge.dwVertexNumber = (*i).second.tGraphID + (*I).second->m_dwOffset;
// (*K).second->vfAddEdge ((*M).second.tGraphID,tGraphEdge);
}
}
}
// counting edges
{
tGraphHeader.m_edge_count = 0;
tGraphHeader.m_death_point_count = 0;
GRAPH_P_PAIR_IT I = tpGraphs.begin();
GRAPH_P_PAIR_IT E = tpGraphs.end();
for ( ; I != E; I++) {
VERIFY ((u32(tGraphHeader.m_edge_count) + (*I).second->dwfGetEdgeCount()) < (u32(1) << (8*sizeof(GameGraph::_GRAPH_ID))));
tGraphHeader.m_edge_count += (GameGraph::_GRAPH_ID)(*I).second->dwfGetEdgeCount();
tGraphHeader.m_death_point_count+= (*I).second->dwfGetDeathPointCount();
}
}
///////////////////////////////////////////////////
// save all the graphs
Phase("Saving graph being merged");
CMemoryWriter F;
tGraphHeader.m_version = XRAI_CURRENT_VERSION;
VERIFY (dwOffset < (u32(1) << (8*sizeof(GameGraph::_GRAPH_ID))));
tGraphHeader.m_vertex_count = (GameGraph::_GRAPH_ID)dwOffset;
tGraphHeader.save (&F);
u32 vertex_count = 0;
dwOffset *= sizeof(CGameGraph::CVertex);
u32 l_dwOffset = F.size();
l_dwPointOffset = dwOffset + tGraphHeader.edge_count()*sizeof(CGameGraph::CEdge);
u32 l_dwStartPointOffset = l_dwPointOffset;
{
GRAPH_P_PAIR_IT I = tpGraphs.begin();
GRAPH_P_PAIR_IT E = tpGraphs.end();
for ( ; I != E; I++) {
(*I).second->vfSaveVertices (F,dwOffset,l_dwPointOffset,&l_tpLevelPoints);
vertex_count += (*I).second->m_tpGraph->header().vertex_count();
}
}
{
GRAPH_P_PAIR_IT I = tpGraphs.begin();
GRAPH_P_PAIR_IT E = tpGraphs.end();
for ( ; I != E; I++)
(*I).second->vfSaveEdges(F);
}
{
l_tpLevelPoints.clear ();
GRAPH_P_PAIR_IT I = tpGraphs.begin();
GRAPH_P_PAIR_IT E = tpGraphs.end();
for ( ; I != E; I++)
l_tpLevelPoints.insert(l_tpLevelPoints.end(),(*I).second->m_tpLevelPoints.begin(),(*I).second->m_tpLevelPoints.end());
}
R_ASSERT2 (l_dwStartPointOffset == F.size() - l_dwOffset,"Graph file format is corrupted");
{
LEVEL_POINT_STORAGE::const_iterator I = l_tpLevelPoints.begin();
LEVEL_POINT_STORAGE::const_iterator E = l_tpLevelPoints.end();
for ( ; I != E; ++I)
save_data (*I,F);
}
{
GRAPH_P_PAIR_IT I = tpGraphs.begin();
GRAPH_P_PAIR_IT E = tpGraphs.end();
for ( ; I != E; I++) {
Msg ("cross_table offset: %d",F.size());
(*I).second->save_cross_table (F);
}
}
string256 l_caFileName;
strcpy_s (l_caFileName,game_graph_id);
F.save_to (l_caFileName);
// free all the graphs
Phase("Freeing resources being allocated");
{
GRAPH_P_PAIR_IT I = tpGraphs.begin();
GRAPH_P_PAIR_IT E = tpGraphs.end();
for ( ; I != E; I++)
xr_free((*I).second);
}
xr_delete (Ini);
}
bool CGameMtlLibrary::Save()
{
R_ASSERT (FALSE==UpdateMtlPairs());
// save
CMemoryWriter fs;
fs.open_chunk (GAMEMTLS_CHUNK_VERSION);
fs.w_u16 (GAMEMTL_CURRENT_VERSION);
fs.close_chunk ();
fs.open_chunk (GAMEMTLS_CHUNK_AUTOINC);
fs.w_u32 (material_index);
fs.w_u32 (material_pair_index);
fs.close_chunk ();
fs.open_chunk (GAMEMTLS_CHUNK_MTLS);
int count = 0;
for(GameMtlIt m_it=materials.begin(); m_it!=materials.end(); m_it++){
fs.open_chunk (count++);
(*m_it)->Save (fs);
fs.close_chunk ();
}
fs.close_chunk ();
fs.open_chunk (GAMEMTLS_CHUNK_MTLS_PAIR);
count = 0;
for(GameMtlPairIt p_it=material_pairs.begin(); p_it!=material_pairs.end(); p_it++){
fs.open_chunk (count++);
(*p_it)->Save (fs);
fs.close_chunk ();
}
fs.close_chunk ();
string_path fn;
FS.update_path (fn,_game_data_,GAMEMTL_FILENAME);
return fs.save_to (fn);
}
