void CSMotion::Save(IWriter& F)
{
CCustomMotion::Save(F);
F.w_u16 (EOBJ_SMOTION_VERSION);
F.w_s8 (m_Flags.get());
F.w_u16 (m_BoneOrPart);
F.w_float (fSpeed);
F.w_float (fAccrue);
F.w_float (fFalloff);
F.w_float (fPower);
F.w_u16 ((u16)bone_mots.size());
for(BoneMotionIt bm_it=bone_mots.begin(); bm_it!=bone_mots.end(); bm_it++){
xr_strlwr (bm_it->name);
F.w_stringZ (bm_it->name);
F.w_u8 (bm_it->m_Flags.get());
for (int ch=0; ch<ctMaxChannel; ch++)
bm_it->envs[ch]->Save(F);
}
#if 0
u32 sz = marks.size();
F.w_u32 (sz);
for(u32 i=0; i<sz; ++i)
marks[i].Save(&F);
#else
F.w_u32 (0);
#endif
}
void ESceneLightTools::Save(IWriter& F)
{
inherited::Save (F);
F.w_chunk (CHUNK_VERSION,(u16*)&LIGHT_TOOLS_VERSION,sizeof(LIGHT_TOOLS_VERSION));
F.open_chunk (CHUNK_FLAGS);
F.w_u32 (m_Flags.get());
F.close_chunk ();
F.open_chunk (CHUNK_SUN_SHADOW);
F.w_u8 (0);
F.w_fvector2 (m_SunShadowDir);
F.close_chunk ();
F.open_chunk (CHUNK_LCONTROLS_LAST);
F.w_u32 (lcontrol_last_idx);
F.close_chunk ();
F.open_chunk (CHUNK_LCONTROLS);
RTokenVecIt _I = lcontrols.begin();
RTokenVecIt _E = lcontrols.end();
for (;_I!=_E; _I++){
F.w_stringZ (_I->name);
F.w_u32 (_I->id);
}
F.close_chunk ();
}
void EDetail::Export(IWriter& F, LPCSTR tex_name, const Fvector2& offs, const Fvector2& scale, bool rot)
{
R_ASSERT (m_pRefs);
CSurface* surf = *m_pRefs->FirstSurface();
R_ASSERT (surf);
// write data
F.w_stringZ (surf->_ShaderName());
F.w_stringZ (tex_name);//surf->_Texture());
F.w_u32 (m_Flags.get());
F.w_float (m_fMinScale);
F.w_float (m_fMaxScale);
F.w_u32 (number_vertices);
F.w_u32 (number_indices);
// remap UV
EVertexIn* rm_vertices = xr_alloc<EVertexIn>(number_vertices);
for (u32 k=0; k<number_vertices; k++) rm_vertices[k].remapUV(vertices[k],offs,scale,rot);
F.w (rm_vertices, number_vertices*sizeof(fvfVertexIn));
F.w (indices, number_indices*sizeof(WORD));
xr_free (rm_vertices);
}
void EDetail::Save(IWriter& F)
{
// version
F.open_chunk (DETOBJ_CHUNK_VERSION);
F.w_u32 (DETOBJ_VERSION);
F.close_chunk ();
// reference
F.open_chunk (DETOBJ_CHUNK_REFERENCE);
F.w_stringZ (m_sRefs.c_str());
F.close_chunk ();
// scale
F.open_chunk (DETOBJ_CHUNK_SCALE_LIMITS);
F.w_float (m_fMinScale);
F.w_float (m_fMaxScale);
F.close_chunk ();
// density factor
F.open_chunk (DETOBJ_CHUNK_DENSITY_FACTOR);
F.w_float (m_fDensityFactor);
F.close_chunk ();
// flags
F.open_chunk (DETOBJ_CHUNK_FLAGS);
F.w_u32 (m_Flags.get());
F.close_chunk ();
}
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);
}
void CCustomMotion::Save(IWriter& F)
{
#ifdef _LW_EXPORT
ReplaceSpaceAndLowerCase(name);
#endif
F.w_stringZ (name);
F.w_u32 (iFrameStart);
F.w_u32 (iFrameEnd);
F.w_float (fFPS);
}
void write( IWriter &w, const CDB::MODEL &m, const xrLC_GlobalData &lc_global_data )
{
w.w_u32( (u32)m.get_verts_count() );
w.w( m.get_verts(), m.get_verts_count() * sizeof(Fvector) );
u32 tris_count = (u32) m.get_tris_count() ;
w.w_u32( tris_count );
for( u32 i = 0; i < tris_count; ++i)
::write( w, m.get_tris()[i], lc_global_data );
// w.w( m.get_tris(), m.get_tris_count() * sizeof(CDB::TRI) );
}
void write( IWriter &w, const CDB::MODEL &m )
{
w.w_u32( (u32)m.get_verts_count() );
w.w( m.get_verts(), m.get_verts_count() * sizeof(Fvector) );
u32 tris_count = (u32) m.get_tris_count() ;
w.w_u32( tris_count );
for( u32 i = 0; i < tris_count; ++i)
::write( w, m.get_tris()[i] );
// w.w( m.get_tris(), m.get_tris_count() * sizeof(CDB::TRI) );
}
//------------------------------------------------------------------------------
// IO - routines
//------------------------------------------------------------------------------
void SGameMtl::Save(IWriter& fs)
{
Flags.set (flSlowDown, !fis_zero(1.f-fFlotationFactor,EPS_L));
Flags.set (flShootable, fis_zero(fShootFactor,EPS_L));
Flags.set (flTransparent, fis_zero(fVisTransparencyFactor,EPS_L));
Flags.set (flInjurious, !fis_zero(fInjuriousSpeed,EPS_L));
fs.open_chunk (GAMEMTL_CHUNK_MAIN);
fs.w_u32 (ID);
fs.w_stringZ (m_Name);
fs.close_chunk ();
fs.open_chunk (GAMEMTL_CHUNK_DESC);
fs.w_stringZ (m_Desc);
fs.close_chunk ();
fs.open_chunk (GAMEMTL_CHUNK_FLAGS);
fs.w_u32 (Flags.get());
fs.close_chunk ();
fs.open_chunk (GAMEMTL_CHUNK_PHYSICS);
fs.w_float (fPHFriction);
fs.w_float (fPHDamping);
fs.w_float (fPHSpring);
fs.w_float (fPHBounceStartVelocity);
fs.w_float (fPHBouncing);
fs.close_chunk ();
fs.open_chunk (GAMEMTL_CHUNK_FACTORS);
fs.w_float (fShootFactor);
fs.w_float (fBounceDamageFactor);
fs.w_float (fVisTransparencyFactor);
fs.w_float (fSndOcclusionFactor);
fs.close_chunk ();
fs.open_chunk (GAMEMTL_CHUNK_FACTORS_MP);
fs.w_float (fShootFactorMP);
fs.close_chunk ();
fs.open_chunk (GAMEMTL_CHUNK_FLOTATION);
fs.w_float (fFlotationFactor);
fs.close_chunk ();
fs.open_chunk (GAMEMTL_CHUNK_INJURIOUS);
fs.w_float (fInjuriousSpeed);
fs.close_chunk ();
fs.open_chunk (GAMEMTL_CHUNK_DENSITY);
fs.w_float (fDensityFactor);
fs.close_chunk ();
}
void SGameMtlPair::Save(IWriter& fs)
{
fs.open_chunk (GAMEMTLPAIR_CHUNK_PAIR);
fs.w_u32 (mtl0);
fs.w_u32 (mtl1);
fs.w_u32 (ID);
fs.w_u32 (ID_parent);
fs.w_u32 (OwnProps.get());
fs.close_chunk ();
// copy from parent
if (ID_parent!=GAMEMTL_NONE_ID){
SGameMtlPair* P;
if ((0!=(P=GetLastParentValue(this,flBreakingSounds)))&&(P!=this))
BreakingSounds = P->BreakingSounds;
if ((0!=(P=GetLastParentValue(this,flStepSounds)))&&(P!=this))
StepSounds = P->StepSounds;
if ((0!=(P=GetLastParentValue(this,flCollideSounds)))&&(P!=this))
CollideSounds = P->CollideSounds;
if ((0!=(P=GetLastParentValue(this,flCollideParticles)))&&(P!=this))
CollideParticles= P->CollideParticles;
if ((0!=(P=GetLastParentValue(this,flCollideMarks)))&&(P!=this))
CollideMarks = P->CollideMarks;
}
/*
else{
OwnProps.zero();
if (!BreakingSounds.IsEmpty()) OwnProps.set(flBreakingSounds,TRUE);
if (!StepSounds.IsEmpty()) OwnProps.set(flStepSounds,TRUE);
if (!CollideSounds.IsEmpty()) OwnProps.set(flCollideSounds,TRUE);
if (!CollideParticles.IsEmpty())OwnProps.set(flCollideParticles,TRUE);
if (!CollideMarks.IsEmpty()) OwnProps.set(flCollideMarks,TRUE);
}
*/
// save
fs.open_chunk (GAMEMTLPAIR_CHUNK_BREAKING);
fs.w_stringZ (BreakingSounds);
fs.close_chunk ();
fs.open_chunk (GAMEMTLPAIR_CHUNK_STEP);
fs.w_stringZ (StepSounds);
fs.close_chunk ();
fs.open_chunk (GAMEMTLPAIR_CHUNK_COLLIDE);
fs.w_stringZ (CollideSounds);
fs.w_stringZ (CollideParticles);
fs.w_stringZ (CollideMarks);
fs.close_chunk ();
}
void write(IWriter &w, const b_texture &b)
{
w.w_string( b.name );
w.w_u32( b.dwWidth );
w.w_u32( b.dwHeight );
w.w_s32( b.bHasAlpha );
bool b_surface = !!b.pSurface;
w.w_u8( u8( b_surface ) );
if(b_surface)
{
u32 size = sizeof( u32 ) * b.dwWidth * b.dwHeight;
w.w( b.pSurface, size );
}
}
void OGF_LOD::Save (IWriter &fs)
{
OGF_Base::Save (fs);
// Header
ogf_header H;
string1024 sid;
strconcat (sid,
pBuild->shader_render[pBuild->materials[lod_Material].shader].name,
"/",
pBuild->textures[pBuild->materials[lod_Material].surfidx].name
);
fs.open_chunk (OGF_HEADER);
H.format_version = xrOGF_FormatVersion;
H.type = MT_LOD;
H.shader_id = RegisterShader(sid);
H.bb.min = bbox.min;
H.bb.max = bbox.max;
H.bs.c = C;
H.bs.r = R;
fs.w (&H,sizeof(H));
fs.close_chunk ();
// Chields
fs.open_chunk (OGF_CHILDREN_L);
fs.w_u32 ((u32)chields.size());
fs.w (&*chields.begin(),(u32)chields.size()*sizeof(u32));
fs.close_chunk ();
// Lod-def
fs.open_chunk (OGF_LODDEF2);
fs.w (lod_faces,sizeof(lod_faces));
fs.close_chunk ();
}
void CPatrolPathStorage::save (IWriter &stream)
{
stream.open_chunk (0);
stream.w_u32 (m_registry.size());
stream.close_chunk ();
stream.open_chunk (1);
PATROL_REGISTRY::iterator I = m_registry.begin();
PATROL_REGISTRY::iterator E = m_registry.end();
for (int i=0; I != E; ++I, ++i) {
stream.open_chunk (i);
stream.open_chunk (0);
save_data ((*I).first,stream);
stream.close_chunk ();
stream.open_chunk (1);
save_data ((*I).second,stream);
stream.close_chunk ();
stream.close_chunk ();
}
stream.close_chunk ();
}
void CGroupObject::Save(IWriter& F)
{
CCustomObject::Save(F);
F.open_chunk (GROUPOBJ_CHUNK_VERSION);
F.w_u16 (GROUPOBJ_CURRENT_VERSION);
F.close_chunk ();
F.w_chunk (GROUPOBJ_CHUNK_FLAGS,&m_Flags,sizeof(m_Flags));
// objects
if (IsOpened()){
F.open_chunk(GROUPOBJ_CHUNK_OPEN_OBJECT_LIST);
F.w_u32 (m_Objects.size());
for (ObjectIt it=m_Objects.begin(); it!=m_Objects.end(); it++)
F.w_stringZ ((*it)->Name);
F.close_chunk ();
}else{
Scene->SaveObjects(m_Objects,GROUPOBJ_CHUNK_OBJECT_LIST,F);
}
F.open_chunk (GROUPOBJ_CHUNK_REFERENCE);
F.w_stringZ (m_ReferenceName);
F.close_chunk ();
}
void xrLC_GlobalData :: write( IWriter &w, const base_Face *f ) const
{
if(!f)
{
w.w_u8( smit_null );
return;
}
const Face *face = dynamic_cast<const Face*>( f );
if(face)
{
VERIFY( write_faces );
w.w_u8( smit_plain );
write_faces->write( w, face );
return;
}
const _face *model_face = dynamic_cast<const _face*>( f );
VERIFY(model_face);
w.w_u8( smit_model );
std::pair<u32,u32> id = get_id( _mu_models, model_face );
w.w_u32( id.first );
_mu_models[ id.first ]->write( w, id.second, model_face );
}
void PDomain::Save(IWriter& F)
{
F.w_u32 (type);
F.w_fvector3(v[0]);
F.w_fvector3(v[1]);
F.w_fvector3(v[2]);
}
void CLAItem::Save(IWriter& F)
{
F.open_chunk (CHUNK_ITEM_COMMON);
F.w_stringZ (cName);
F.w_float (fFPS);
F.w_u32 (iFrameCount);
F.close_chunk ();
F.open_chunk (CHUNK_ITEM_KEYS);
F.w_u32 (Keys.size());
for (KeyPairIt it=Keys.begin(); it!=Keys.end(); it++){
F.w_u32 (it->first);
F.w_u32 (it->second);
}
F.close_chunk ();
}
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 ();
}
void CParticleManager::SaveActions(int alist_id, IWriter& W)
{
// Execute the specified action list.
ParticleActions* pa = GetActionListPtr(alist_id);
W.w_u32 (pa->size());
for (PAVecIt it=pa->begin(); it!=pa->end(); it++)
(*it)->Save (W);
}
void EScene::SaveObjectStream( CCustomObject* O, IWriter& F )
{
F.open_chunk (CHUNK_OBJECT_CLASS);
F.w_u32 (O->ClassID);
F.close_chunk ();
F.open_chunk (CHUNK_OBJECT_BODY);
O->SaveStream (F);
F.close_chunk ();
}
void _face::write( IWriter &w ) const
{
base_Face::write( w );
w.w_fvector2( tc[0] );
w.w_fvector2( tc[1] );
w.w_fvector2( tc[2] );
w.w_fvector3( N );
w.w_u32( sm_group );
}
void CEditableObject::SaveBoneData(IWriter& F)
{
for (BoneIt b_it=m_Bones.begin(); b_it!=m_Bones.end(); b_it++){
F.open_chunk (b_it-m_Bones.begin());
(*b_it)->SaveData (F);
F.close_chunk ();
}
// save bone part
F.open_chunk (EOBJ_CHUNK_BONEPARTS2);
F.w_u32 (m_BoneParts.size());
for (BPIt bp_it=m_BoneParts.begin(); bp_it!=m_BoneParts.end(); bp_it++){
F.w_stringZ (bp_it->alias.c_str());
F.w_u32 (bp_it->bones.size());
for (RStringVecIt s_it=bp_it->bones.begin(); s_it!=bp_it->bones.end(); s_it++)
F.w_stringZ(*s_it);
}
F.close_chunk ();
}
void ESceneSpawnTool::SaveStream(IWriter& F)
{
inherited::SaveStream (F);
F.w_chunk (CHUNK_VERSION,(u16*)&SPAWN_TOOLS_VERSION,sizeof(SPAWN_TOOLS_VERSION));
F.open_chunk (CHUNK_FLAGS);
F.w_u32 (m_Flags.get());
F.close_chunk ();
}
void EDetailManager::SaveStream(IWriter& F)
{
inherited::SaveStream (F);
// version
F.open_chunk (DETMGR_CHUNK_VERSION);
F.w_u32 (DETMGR_VERSION);
F.close_chunk ();
F.open_chunk (DETMGR_CHUNK_FLAGS);
F.w_u32 (m_Flags.get());
F.close_chunk ();
// header
F.w_chunk (DETMGR_CHUNK_HEADER,&dtH,sizeof(DetailHeader));
// objects
SaveColorIndices (F);
// slots
F.open_chunk (DETMGR_CHUNK_SLOTS);
F.w_u32 (dtH.size_x*dtH.size_z);
F.w (dtSlots,dtH.size_x*dtH.size_z*sizeof(DetailSlot));
F.close_chunk ();
// internal
// bbox
F.w_chunk (DETMGR_CHUNK_BBOX,&m_BBox,sizeof(Fbox));
// base texture
if (m_Base.Valid()){
F.open_chunk (DETMGR_CHUNK_BASE_TEXTURE);
F.w_stringZ (m_Base.GetName());
F.close_chunk ();
}
F.open_chunk (DETMGR_CHUNK_DENSITY);
F.w_float (ps_r__Detail_density);
F.close_chunk ();
// snap objects
F.open_chunk (DETMGR_CHUNK_SNAP_OBJECTS);
F.w_u32 (m_SnapObjects.size());
for (ObjectIt o_it=m_SnapObjects.begin(); o_it!=m_SnapObjects.end(); o_it++)
F.w_stringZ ((*o_it)->Name);
F.close_chunk ();
}
void ESceneAIMapTool::SaveStream(IWriter& F)
{
inherited::SaveStream (F);
F.open_chunk (AIMAP_CHUNK_VERSION);
F.w_u16 (AIMAP_VERSION);
F.close_chunk ();
F.open_chunk (AIMAP_CHUNK_FLAGS);
F.w (&m_Flags,sizeof(m_Flags));
F.close_chunk ();
F.open_chunk (AIMAP_CHUNK_BOX);
F.w (&m_AIBBox,sizeof(m_AIBBox));
F.close_chunk ();
F.open_chunk (AIMAP_CHUNK_PARAMS);
F.w (&m_Params,sizeof(m_Params));
F.close_chunk ();
EnumerateNodes ();
F.open_chunk (AIMAP_CHUNK_NODES);
F.w_u32 (m_Nodes.size());
for (AINodeIt it=m_Nodes.begin(); it!=m_Nodes.end(); it++)
(*it)->SaveStream (F,this);
F.close_chunk ();
F.open_chunk (AIMAP_CHUNK_INTERNAL_DATA);
F.w_float (m_VisRadius);
F.w_u32 (m_BrushSize);
F.close_chunk ();
F.open_chunk (AIMAP_CHUNK_INTERNAL_DATA2);
F.w_float (m_SmoothHeight);
F.close_chunk ();
F.open_chunk (AIMAP_CHUNK_SNAP_OBJECTS);
F.w_u32 (m_SnapObjects.size());
for (ObjectIt o_it=m_SnapObjects.begin(); o_it!=m_SnapObjects.end(); o_it++)
F.w_stringZ ((*o_it)->Name);
F.close_chunk ();
}
void STextureParams::Save(IWriter& F)
{
F.open_chunk (THM_CHUNK_TEXTUREPARAM);
F.w (&fmt,sizeof(ETFormat));
F.w_u32 (flags.get());
F.w_u32 (border_color);
F.w_u32 (fade_color);
F.w_u32 (fade_amount);
F.w_u32 (mip_filter);
F.w_u32 (width);
F.w_u32 (height);
F.close_chunk ();
F.open_chunk (THM_CHUNK_TEXTURE_TYPE);
F.w_u32 (type);
F.close_chunk ();
F.open_chunk (THM_CHUNK_DETAIL_EXT);
F.w_stringZ (detail_name);
F.w_float (detail_scale);
F.close_chunk ();
F.open_chunk (THM_CHUNK_MATERIAL);
F.w_u32 (material);
F.w_float (material_weight);
F.close_chunk ();
F.open_chunk (THM_CHUNK_BUMP);
F.w_float (bump_virtual_height);
F.w_u32 (bump_mode);
F.w_stringZ (bump_name);
F.close_chunk ();
F.open_chunk (THM_CHUNK_EXT_NORMALMAP);
F.w_stringZ (ext_normal_map_name);
F.close_chunk ();
F.open_chunk (THM_CHUNK_FADE_DELAY);
F.w_u8 (fade_delay);
F.close_chunk ();
}
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 st_LevelOptions::Save( IWriter& F )
{
F.open_chunk( CHUNK_LO_VERSION );
F.w_u32 ( CURRENT_LEVELOP_VERSION );
F.close_chunk();
F.open_chunk( CHUNK_LO_NAMES );
F.w_stringZ ( m_FNLevelPath.size()?m_FNLevelPath.c_str():"" );
F.close_chunk();
F.open_chunk( CHUNK_LO_PREFIX );
F.w_stringZ ( m_LevelPrefix.size()?m_LevelPrefix.c_str():"");
F.close_chunk();
F.open_chunk( CHUNK_LO_BOP );
F.w_stringZ ( m_BOPText.size()?m_BOPText.c_str():"" );
F.close_chunk();
F.open_chunk( CHUNK_LO_MAP_VER );
F.w_stringZ ( m_map_version.size()?m_map_version.c_str():"1.0" );
F.close_chunk();
F.open_chunk( CHUNK_LO_BP_VERSION );
F.w_u32 ( CURRENT_LEVELOP_BP_VERSION );
F.close_chunk();
F.open_chunk( CHUNK_BUILD_PARAMS );
F.w ( &m_BuildParams, sizeof(m_BuildParams) );
F.close_chunk();
F.open_chunk( CHUNK_LIGHT_QUALITY );
F.w_u8 ( m_LightHemiQuality );
F.w_u8 ( m_LightSunQuality );
F.close_chunk();
F.open_chunk( CHUNK_MAP_USAGE );
F.w_u16 ( m_mapUsage.m_GameType.get() );
F.close_chunk();
}
void ESceneObjectTools::Save(IWriter& F)
{
inherited::Save(F);
F.w_chunk (CHUNK_VERSION,(u16*)&OBJECT_TOOLS_VERSION,sizeof(OBJECT_TOOLS_VERSION));
F.open_chunk (CHUNK_FLAGS);
F.w_u32 (m_Flags.get());
F.close_chunk ();
F.open_chunk (CHUNK_APPEND_RANDOM);
F.w_fvector3 (m_AppendRandomMinScale);
F.w_fvector3 (m_AppendRandomMaxScale);
F.w_fvector3 (m_AppendRandomMinRotation);
F.w_fvector3 (m_AppendRandomMaxRotation);
F.w_u32 (m_AppendRandomObjects.size());
if (m_AppendRandomObjects.size()){
for (RStringVecIt it=m_AppendRandomObjects.begin(); it!=m_AppendRandomObjects.end(); it++)
F.w_stringZ(*it);
}
F.close_chunk ();
}
void CEditShape::Save(IWriter& F)
{
inherited::Save (F);
F.open_chunk (SHAPE_CHUNK_VERSION);
F.w_u16 (SHAPE_CURRENT_VERSION);
F.close_chunk ();
F.open_chunk (SHAPE_CHUNK_SHAPES);
F.w_u32 (shapes.size());
F.w (shapes.begin(),shapes.size()*sizeof(shape_def));
F.close_chunk ();
}
