void CGroupObject::SaveStream(IWriter& F)
{
CCustomObject::SaveStream(F);
F.open_chunk (GROUPOBJ_CHUNK_VERSION);
F.w_u16 (GROUPOBJ_CURRENT_VERSION);
F.close_chunk ();
{
ObjectList grp_lst;
GetObjects (grp_lst);
ObjectList::iterator it;
for (it=grp_lst.begin(); it!=grp_lst.end(); ++it)
(*it)->m_CO_Flags.set(CCustomObject::flObjectInGroup, FALSE);
Scene->SaveObjectsStream(grp_lst,GROUPOBJ_CHUNK_OBJECT_LIST,F);
for (it=grp_lst.begin(); it!=grp_lst.end(); ++it)
(*it)->m_CO_Flags.set(CCustomObject::flObjectInGroup, TRUE);
}
F.open_chunk (GROUPOBJ_CHUNK_REFERENCE);
F.w_stringZ (m_ReferenceName_);
F.close_chunk ();
}
void SaveGEOMs (LPCSTR fn, VBContainer& vb, IBContainer& ib, SWIContainer& swi)
{
Status ("Geometry '%s'...", fn);
// geometry
string_path lfn ;
IWriter* file ;
file = FS.w_open (strconcat(sizeof(lfn),lfn,pBuild->path,fn));
hdrLEVEL H; H.XRLC_version = XRCL_PRODUCTION_VERSION;
file->w_chunk (fsL_HEADER,&H,sizeof(H));
// verts
file->open_chunk (fsL_VB);
vb.Save (*file);
file->close_chunk ();
// indices
file->open_chunk (fsL_IB);
ib.Save (*file);
file->close_chunk ();
// swis
file->open_chunk (fsL_SWIS);
swi.Save (*file);
file->close_chunk ();
}
void TClipMaker::SaveClips()
{
if (!clips.empty()){
if (EFS.GetSaveName("$clips$",m_ClipFName)){
IWriter* F = FS.w_open(m_ClipFName.c_str()); VERIFY(F);
m_ClipFName = EFS.ExcludeBasePath(m_ClipFName.c_str(),FS.get_path("$clips$")->m_Path);
if (F){
F->open_chunk(CHUNK_ZOOM);
F->w_float (m_Zoom);
F->close_chunk();
F->open_chunk (CHUNK_CLIPS);
int count = 0;
for (UIClipIt c_it=clips.begin(); c_it!=clips.end(); c_it++){
F->open_chunk(count); count++;
(*c_it)->Save(*F);
F->close_chunk();
}
F->close_chunk ();
FS.w_close(F);
}else{
Log ("!Can't save clip:",m_ClipFName.c_str());
}
}
}else{
ELog.DlgMsg(mtError,"Clip list empty.");
}
}
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 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 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 ESoundSource::Save(IWriter& F)
{
inherited::Save (F);
F.open_chunk (SOUND_CHUNK_VERSION);
F.w_u16 (SOUND_SOURCE_VERSION);
F.close_chunk ();
F.w_chunk (SOUND_CHUNK_TYPE,&m_Type,sizeof(m_Type));
F.open_chunk (SOUND_CHUNK_SOURCE_NAME);
F.w_stringZ (m_WAVName);
F.close_chunk ();
F.w_chunk (SOUND_CHUNK_SOURCE_FLAGS,&m_Flags,sizeof(m_Flags));
F.open_chunk (SOUND_CHUNK_SOURCE_PARAMS3);
F.w_fvector3 (m_Params.position);
F.w_float (m_Params.volume);
F.w_float (m_Params.freq);
F.w_float (m_Params.min_distance);
F.w_float (m_Params.max_distance);
F.w_float (m_Params.max_ai_distance);
F.close_chunk ();
F.open_chunk (SOUND_CHUNK_GAME_PARAMS);
F.w_fvector2 (m_RandomPause);
F.w_fvector2 (m_ActiveTime);
F.w_fvector2 (m_PlayTime);
F.close_chunk ();
}
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 OGF::Save_Normal_PM (IWriter &fs, ogf_header& H, BOOL bVertexColored)
{
// clMsg ("- saving: normal or clod");
// Vertices
fs.open_chunk (OGF_GCONTAINER);
fs.w_u32 (vb_id);
fs.w_u32 (vb_start);
fs.w_u32 ((u32)vertices.size());
fs.w_u32 (ib_id);
fs.w_u32 (ib_start);
fs.w_u32 ((u32)faces.size()*3);
fs.close_chunk ();
// progressive-data, if need it
if (H.type == MT_PROGRESSIVE){
// SW
fs.open_chunk (OGF_SWIDATA );
fs.w_u32 (m_SWI.reserved[0] );
fs.w_u32 (m_SWI.reserved[1] );
fs.w_u32 (m_SWI.reserved[2] );
fs.w_u32 (m_SWI.reserved[3] );
fs.w_u32 (m_SWI.count );
fs.w (m_SWI.sw,m_SWI.count*sizeof(FSlideWindow));
fs.close_chunk ();
}
// if has x-vertices/x-faces
if (x_vertices.size() && x_faces.size()) {
fs.open_chunk (OGF_FASTPATH );
{
// Vertices
fs.open_chunk (OGF_GCONTAINER);
fs.w_u32 (xvb_id);
fs.w_u32 (xvb_start);
fs.w_u32 ((u32)x_vertices.size());
fs.w_u32 (xib_id);
fs.w_u32 (xib_start);
fs.w_u32 ((u32)x_faces.size()*3);
fs.close_chunk ();
// progressive-data, if need it
if (H.type == MT_PROGRESSIVE){
// SW
fs.open_chunk (OGF_SWIDATA );
fs.w_u32 (x_SWI.reserved[0] );
fs.w_u32 (x_SWI.reserved[1] );
fs.w_u32 (x_SWI.reserved[2] );
fs.w_u32 (x_SWI.reserved[3] );
fs.w_u32 (x_SWI.count );
fs.w (x_SWI.sw,x_SWI.count*sizeof(FSlideWindow));
fs.close_chunk ();
}
}
fs.close_chunk ();
}
}
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 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 ESoundEnvironment::SaveStream(IWriter& F)
{
inherited::SaveStream (F);
F.open_chunk (SOUND_CHUNK_VERSION);
F.w_u16 (SOUND_ENV_VERSION);
F.close_chunk ();
F.open_chunk (SOUND_CHUNK_ENV_REFS);
F.w_stringZ (m_EnvInner);
F.w_stringZ (m_EnvOuter);
F.close_chunk ();
}
void EScene::SaveObjectsStream( ObjectList& lst, u32 chunk_id, IWriter& F )
{
F.open_chunk (chunk_id);
int count = 0;
for(ObjectIt _F = lst.begin();_F!=lst.end();++_F)
{
F.open_chunk (count);
++count;
SaveObjectStream (*_F,F);
F.close_chunk ();
}
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 ();
}
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 ESceneCustomOTools::SaveSelection(IWriter& F)
{
F.open_chunk (CHUNK_OBJECTS);
int count = 0;
for(ObjectIt it = m_Objects.begin();it!=m_Objects.end();it++){
if ((*it)->Selected() && !(*it)->IsDeleted()){
F.open_chunk(count++);
Scene->SaveObject(*it,F);
F.close_chunk();
}
}
F.close_chunk ();
F.w_chunk (CHUNK_OBJECT_COUNT,&count,sizeof(count));
}
bool ESceneAIMapTools::Export(LPCSTR path)
{
//.? if (!RealUpdateSnapList()) return false;
if (!Valid()) return false;
// calculate bbox
Fbox bb; CalculateNodesBBox(bb);
AnsiString fn = AnsiString(path)+"build.aimap";
// export
IWriter* F = FS.w_open(fn.c_str());
if (F){
F->open_chunk (E_AIMAP_CHUNK_VERSION);
F->w_u16 (E_AIMAP_VERSION);
F->close_chunk ();
F->open_chunk (E_AIMAP_CHUNK_BOX);
F->w (&bb,sizeof(bb));
F->close_chunk ();
F->open_chunk (E_AIMAP_CHUNK_PARAMS);
F->w (&m_Params,sizeof(m_Params));
F->close_chunk ();
EnumerateNodes ();
F->open_chunk (E_AIMAP_CHUNK_NODES);
F->w_u32 (m_Nodes.size());
for (AINodeIt it=m_Nodes.begin(); it!=m_Nodes.end(); it++){
u32 id;
u16 pl;
NodePosition np;
id = (*it)->n1?(u32)(*it)->n1->idx:InvalidNode; F->w(&id,3);
id = (*it)->n2?(u32)(*it)->n2->idx:InvalidNode; F->w(&id,3);
id = (*it)->n3?(u32)(*it)->n3->idx:InvalidNode; F->w(&id,3);
id = (*it)->n4?(u32)(*it)->n4->idx:InvalidNode; F->w(&id,3);
pl = pvCompress ((*it)->Plane.n); F->w_u16(pl);
PackPosition (np,(*it)->Pos,bb,m_Params); F->w(&np,sizeof(np));
}
F->close_chunk ();
FS.w_close (F);
return true;
}
return false;
}
bool CEditableObject::SaveObject(const char* fname)
{
if (IsModified()){
// update transform matrix
Fmatrix mTransform,mScale,mTranslate,mRotate;
if (!fsimilar(t_vRotate.magnitude(),0)||!fsimilar(t_vScale.magnitude(),1.73205f)||!fsimilar(t_vPosition.magnitude(),0)){
mRotate.setHPB (t_vRotate.y, t_vRotate.x, t_vRotate.z);
mScale.scale (t_vScale);
mTranslate.translate (t_vPosition);
mTransform.mul (mTranslate,mRotate);
mTransform.mulB_43 (mScale);
TranslateToWorld (mTransform);
t_vRotate.set (0,0,0);
t_vPosition.set (0,0,0);
t_vScale.set (1,1,1);
}
}
// save object
IWriter* F = FS.w_open(fname);
if (F){
F->open_chunk (EOBJ_CHUNK_OBJECT_BODY);
Save (*F);
F->close_chunk ();
FS.w_close (F);
m_LoadName = fname;
m_ObjectVersion = FS.get_file_age(fname); VERIFY3(m_ObjectVersion>0,"Invalid file age:",fname);
return true;
}else{
return false;
}
}
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 CALifeSpawnRegistry::save (IWriter &memory_stream)
{
Msg ("* Saving spawns...");
memory_stream.open_chunk (SPAWN_CHUNK_DATA);
memory_stream.open_chunk (0);
memory_stream.w_stringZ (m_spawn_name);
memory_stream.w (&header().guid(),sizeof(header().guid()));
memory_stream.close_chunk ();
memory_stream.open_chunk (1);
save_updates (memory_stream);
memory_stream.close_chunk ();
memory_stream.close_chunk ();
}
//------------------------------------------------------------------------------
// 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 CClip::Save(IWriter& F)
{
F.open_chunk (EOBJ_CLIP_VERSION_CHUNK);
F.w_u16 (EOBJ_CLIP_VERSION);
F.close_chunk ();
F.open_chunk (EOBJ_CLIP_DATA_CHUNK);
F.w_stringZ (name);
for (int k=0; k<4; k++){
F.w_stringZ (cycles[k].name);
F.w_u16 (cycles[k].slot);
}
F.w_stringZ (fx.name);
F.w_u16 (fx.slot);
F.w_float (fx_power);
F.w_float (length);
F.close_chunk ();
}
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 EParticlesObject::Save(IWriter& F)
{
CCustomObject::Save(F);
F.open_chunk (CPSOBJECT_CHUNK_VERSION);
F.w_u16 (CPSOBJECT_VERSION);
F.close_chunk ();
//. VERIFY(m_PE.GetDefinition());
F.open_chunk (CPSOBJECT_CHUNK_REFERENCE);
F.w_stringZ (m_RefName);
F.close_chunk ();
/*
F.open_chunk (CPSOBJECT_CHUNK_PARAMS);
F.w_u32 (m_PE.m_RT_Flags.get());
F.close_chunk ();
*/
}
void CALifeSpawnRegistry::save_updates (IWriter &stream)
{
SPAWN_GRAPH::vertex_iterator I = m_spawns.vertices().begin();
SPAWN_GRAPH::vertex_iterator E = m_spawns.vertices().end();
for ( ; I != E; ++I) {
stream.open_chunk ((*I).second->vertex_id());
(*I).second->data()->save_update (stream);
stream.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 ESceneCustomMTools::Save(IWriter& F)
{
xr_string mn = AnsiString().sprintf("\\\\%s\\%s",Core.CompName,Core.UserName).c_str();
time_t mt = time(NULL);
F.open_chunk (CHUNK_TOOLS_TAG);
F.w_stringZ (mn);
F.w (&mt,sizeof(mt));
F.close_chunk ();
}
void CLight::Save(IWriter& F)
{
CCustomObject::Save(F);
F.open_chunk (LIGHT_CHUNK_VERSION);
F.w_u16 (LIGHT_VERSION);
F.close_chunk ();
F.open_chunk (LIGHT_CHUNK_PARAMS);
F.w_u32 (m_Type);
F.w_fcolor (m_Color);
F.w_float (m_Brightness);
F.w_float (m_Range);
F.w_float (m_Attenuation0);
F.w_float (m_Attenuation1);
F.w_float (m_Attenuation2);
F.w_float (m_Cone);
F.w_float (m_VirtualSize);
F.close_chunk ();
F.w_chunk (LIGHT_CHUNK_USE_IN_D3D,&m_UseInD3D,sizeof(m_UseInD3D));
F.w_chunk (LIGHT_CHUNK_FLAG,&m_Flags,sizeof(m_Flags));
F.w_chunk (LIGHT_CHUNK_LCONTROL,&m_LControl,sizeof(m_LControl));
if (m_pAnimRef){
F.open_chunk(LIGHT_CHUNK_ANIMREF);
F.w_stringZ (m_pAnimRef->cName);
F.close_chunk();
}
if (m_FalloffTex.size()){
F.open_chunk(LIGHT_CHUNK_FALLOFF_TEXTURE);
F.w_stringZ (m_FalloffTex);
F.close_chunk();
}
if (m_Flags.is(ELight::flPointFuzzy)){
VERIFY(m_FuzzyData);
F.open_chunk(LIGHT_CHUNK_FUZZY_DATA);
m_FuzzyData->Save(F);
F.close_chunk();
}
}
void CBone::Save(IWriter& F)
{
F.open_chunk (BONE_CHUNK_VERSION);
F.w_u16 (BONE_VERSION);
F.close_chunk ();
F.open_chunk (BONE_CHUNK_DEF);
F.w_stringZ (name);
F.w_stringZ (parent_name);
F.w_stringZ (wmap);
F.close_chunk ();
F.open_chunk (BONE_CHUNK_BIND_POSE);
F.w_fvector3 (rest_offset);
F.w_fvector3 (rest_rotate);
F.w_float (rest_length);
F.close_chunk ();
SaveData (F);
}
