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);
}
u32 sz = marks.size();
F.w_u32 (sz);
for(u32 i=0; i<sz; ++i)
marks[i].Save(&F);
}
void base_Face:: write ( IWriter &w )const
{
w_pod<base_basis[3]>( w, basis_tangent );
w_pod<base_basis[3]>( w, basis_binormal );
w.w_u16( dwMaterial );
w.w_u16( dwMaterialGame );
w_pod( w, flags );
}
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;
}
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 COMotion::Save(IWriter& F)
{
CCustomMotion::Save(F);
F.w_u16 (EOBJ_OMOTION_VERSION);
for (int ch=0; ch<ctMaxChannel; ch++)
envs[ch]->Save(F);
}
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 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 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 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 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 CGlow::Save(IWriter& F){
CCustomObject::Save(F);
F.open_chunk (GLOW_CHUNK_VERSION);
F.w_u16 (GLOW_VERSION);
F.close_chunk ();
F.open_chunk (GLOW_CHUNK_PARAMS);
F.w_float (m_fRadius);
F.close_chunk ();
F.open_chunk (GLOW_CHUNK_SHADER);
F.w_stringZ (m_ShaderName);
F.close_chunk ();
F.open_chunk (GLOW_CHUNK_TEXTURE);
F.w_stringZ (m_TexName);
F.close_chunk ();
F.open_chunk (GLOW_CHUNK_FLAGS);
F.w_u16 (m_Flags.get());
F.close_chunk ();
}
void SAINode::SaveStream(IWriter& F, ESceneAIMapTool* tools)
{
u32 id;
u16 pl;
NodePosition np;
id = n1?(u32)n1->idx:InvalidNode; F.w(&id,3);
id = n2?(u32)n2->idx:InvalidNode; F.w(&id,3);
id = n3?(u32)n3->idx:InvalidNode; F.w(&id,3);
id = n4?(u32)n4->idx:InvalidNode; F.w(&id,3);
pl = pvCompress (Plane.n); F.w_u16(pl);
tools->PackPosition(np,Pos,tools->m_AIBBox,tools->m_Params); F.w(&np,sizeof(np));
F.w_u8 (flags.get());
}
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 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 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 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);
}
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 CPGDef::Save(IWriter& F)
{
F.open_chunk (PGD_CHUNK_VERSION);
F.w_u16 (PGD_VERSION);
F.close_chunk ();
F.open_chunk (PGD_CHUNK_NAME);
F.w_stringZ (m_Name);
F.close_chunk ();
F.w_chunk (PGD_CHUNK_FLAGS,&m_Flags,sizeof(m_Flags));
F.open_chunk (PGD_CHUNK_EFFECTS);
F.w_u32 (m_Effects.size());
for (EffectIt it=m_Effects.begin(); it!=m_Effects.end(); it++){
F.w_stringZ ((*it)->m_EffectName);
F.w_stringZ ((*it)->m_OnPlayChildName);
F.w_stringZ ((*it)->m_OnBirthChildName);
F.w_stringZ ((*it)->m_OnDeadChildName);
F.w_float ((*it)->m_Time0);
F.w_float ((*it)->m_Time1);
F.w_u32 ((*it)->m_Flags.get());
}
F.close_chunk ();
F.open_chunk (PGD_CHUNK_TIME_LIMIT);
F.w_float (m_fTimeLimit);
F.close_chunk ();
#ifdef _EDITOR
F.open_chunk (PGD_CHUNK_OWNER);
F.w_stringZ (m_OwnerName);
F.w_stringZ (m_ModifName);
F.w (&m_CreateTime,sizeof(m_CreateTime));
F.w (&m_ModifTime,sizeof(m_ModifTime));
F.close_chunk ();
#endif
}
void CPEDef::Save(IWriter& F)
{
F.open_chunk (PED_CHUNK_VERSION);
F.w_u16 (PED_VERSION);
F.close_chunk ();
F.open_chunk (PED_CHUNK_NAME);
F.w_stringZ (m_Name);
F.close_chunk ();
F.open_chunk (PED_CHUNK_EFFECTDATA);
F.w_u32 (m_MaxParticles);
F.close_chunk ();
F.open_chunk (PED_CHUNK_ACTIONLIST);
F.w (m_Actions.pointer(),m_Actions.size());
F.close_chunk ();
F.w_chunk (PED_CHUNK_FLAGS,&m_Flags,sizeof(m_Flags));
if (m_Flags.is(dfSprite))
{
F.open_chunk (PED_CHUNK_SPRITE);
F.w_stringZ (m_ShaderName);
F.w_stringZ (m_TextureName);
F.close_chunk ();
}
if (m_Flags.is(dfFramed))
{
F.open_chunk (PED_CHUNK_FRAME);
F.w (&m_Frame,sizeof(SFrame));
F.close_chunk ();
}
if (m_Flags.is(dfTimeLimit))
{
F.open_chunk (PED_CHUNK_TIMELIMIT);
F.w_float (m_fTimeLimit);
F.close_chunk ();
}
if (m_Flags.is(dfCollision))
{
F.open_chunk (PED_CHUNK_COLLISION);
F.w_float (m_fCollideOneMinusFriction);
F.w_float (m_fCollideResilience);
F.w_float (m_fCollideSqrCutoff);
F.close_chunk ();
}
if (m_Flags.is(dfVelocityScale))
{
F.open_chunk (PED_CHUNK_VEL_SCALE);
F.w_fvector3 (m_VelocityScale);
F.close_chunk ();
}
if (m_Flags.is(dfAlignToPath))
{
F.open_chunk (PED_CHUNK_ALIGN_TO_PATH);
F.w_fvector3 (m_APDefaultRotation);
F.close_chunk ();
}
#ifdef _EDITOR
F.open_chunk (PED_CHUNK_EDATA);
F.w_u32 (m_EActionList.size());
for (EPAVecIt it=m_EActionList.begin(); it!=m_EActionList.end(); it++){
F.w_u32 ((*it)->type);
(*it)->Save (F);
}
F.close_chunk ();
#endif
}
void CEditableMesh::SaveMesh(IWriter& F){
F.open_chunk (EMESH_CHUNK_VERSION);
F.w_u16 (EMESH_CURRENT_VERSION);
F.close_chunk ();
F.open_chunk (EMESH_CHUNK_MESHNAME);
F.w_stringZ (m_Name);
F.close_chunk ();
F.w_chunk (EMESH_CHUNK_BBOX,&m_Box, sizeof(m_Box));
F.w_chunk (EMESH_CHUNK_FLAGS,&m_Flags,1);
F.w_chunk (EMESH_CHUNK_BOP,&m_Ops, sizeof(m_Ops));
F.open_chunk (EMESH_CHUNK_VERTS);
F.w_u32 (m_VertCount);
F.w (m_Verts, m_VertCount*sizeof(Fvector));
/*
for (AdjIt a_it=m_Adjs.begin(); a_it!=m_Adjs.end(); a_it++){
int sz = a_it->size(); VERIFY(sz<=255);
F.w_u8 ((u8)sz);
F.w (&*a_it->begin(), sizeof(int)*sz);
}
*/
F.close_chunk ();
F.open_chunk (EMESH_CHUNK_FACES);
F.w_u32 (m_FaceCount); /* polygon count */
F.w (m_Faces, m_FaceCount*sizeof(st_Face));
F.close_chunk ();
if (m_SGs){
F.open_chunk (EMESH_CHUNK_SG);
F.w (m_SGs, m_FaceCount*sizeof(u32));
F.close_chunk ();
}
F.open_chunk (EMESH_CHUNK_VMREFS);
F.w_u32 (m_VMRefs.size());
for (VMRefsIt r_it=m_VMRefs.begin(); r_it!=m_VMRefs.end(); r_it++){
int sz = r_it->count; VERIFY(sz<=255);
F.w_u8 ((u8)sz);
F.w (r_it->pts, sizeof(st_VMapPt)*sz);
}
F.close_chunk ();
F.open_chunk (EMESH_CHUNK_SFACE);
F.w_u16 ((u16)m_SurfFaces.size()); /* surface polygon count*/
for (SurfFacesPairIt plp_it=m_SurfFaces.begin(); plp_it!=m_SurfFaces.end(); plp_it++){
F.w_stringZ (plp_it->first->_Name()); /* surface name*/
IntVec& pol_lst = plp_it->second;
F.w_u32 (pol_lst.size()); /* surface-polygon indices*/
F.w (&*pol_lst.begin(), sizeof(int)*pol_lst.size());
}
F.close_chunk ();
F.open_chunk (EMESH_CHUNK_VMAPS_2);
F.w_u32 (m_VMaps.size());
for (VMapIt vm_it=m_VMaps.begin(); vm_it!=m_VMaps.end(); vm_it++){
F.w_stringZ ((*vm_it)->name);
F.w_u8 ((*vm_it)->dim);
F.w_u8 ((u8)(*vm_it)->polymap);
F.w_u8 ((*vm_it)->type);
F.w_u32 ((*vm_it)->size());
F.w ((*vm_it)->getVMdata(), (*vm_it)->VMdatasize());
F.w ((*vm_it)->getVIdata(), (*vm_it)->VIdatasize());
if ((*vm_it)->polymap)
F.w ((*vm_it)->getPIdata(), (*vm_it)->PIdatasize());
}
F.close_chunk ();
}
void CMapLocation::save(IWriter &stream)
{
stream.w_u16 (RefCount());
stream.w_stringZ(m_hint);
stream.w_u32 (m_flags.flags);
}
void CBuild::Run (LPCSTR P)
{
if (strstr(Core.Params,"-att")) gl_linear = TRUE;
//****************************************** Open Level
strconcat (path,P,"\\") ;
string_path lfn ;
IWriter* fs = FS.w_open (strconcat(lfn,path,"level."));
fs->open_chunk (fsL_HEADER) ;
hdrLEVEL H;
H.XRLC_version = XRCL_PRODUCTION_VERSION;
H.XRLC_quality = g_params.m_quality;
fs->w (&H,sizeof(H));
fs->close_chunk ();
//****************************************** Dumb entry in shader-registration
RegisterShader ("");
//****************************************** Saving lights
{
string256 fn;
IWriter* fs = FS.w_open (strconcat(fn,pBuild->path,"build.lights"));
fs->w_chunk (0,&*L_static.rgb.begin(),L_static.rgb.size()*sizeof(R_Light));
fs->w_chunk (1,&*L_static.hemi.begin(),L_static.hemi.size()*sizeof(R_Light));
fs->w_chunk (2,&*L_static.sun.begin(),L_static.sun.size()*sizeof(R_Light));
FS.w_close (fs);
}
//****************************************** Optimizing + checking for T-junctions
FPU::m64r ();
Phase ("Optimizing...");
mem_Compact ();
PreOptimize ();
CorrectTJunctions ();
//****************************************** HEMI-Tesselate
FPU::m64r ();
Phase ("Adaptive HT...");
mem_Compact ();
#ifndef CFORM_ONLY
xrPhase_AdaptiveHT ();
#endif
//****************************************** Building normals
FPU::m64r ();
Phase ("Building normals...");
mem_Compact ();
CalcNormals ();
//SmoothVertColors (5);
//****************************************** Collision DB
//should be after normals, so that double-sided faces gets separated
FPU::m64r ();
Phase ("Building collision database...");
mem_Compact ();
BuildCForm ();
#ifdef CFORM_ONLY
return;
#endif
BuildPortals (*fs);
//****************************************** T-Basis
{
FPU::m64r ();
Phase ("Building tangent-basis...");
xrPhase_TangentBasis ();
mem_Compact ();
}
//****************************************** GLOBAL-RayCast model
FPU::m64r ();
Phase ("Building rcast-CFORM model...");
mem_Compact ();
Light_prepare ();
BuildRapid (TRUE);
//****************************************** GLOBAL-ILLUMINATION
if (b_radiosity)
{
FPU::m64r ();
Phase ("Radiosity-Solver...");
mem_Compact ();
Light_prepare ();
xrPhase_Radiosity ();
}
//****************************************** Starting MU
FPU::m64r ();
Phase ("LIGHT: Starting MU...");
mem_Compact ();
Light_prepare ();
mu_base.start (xr_new<CMUThread> (0));
//****************************************** Resolve materials
FPU::m64r ();
Phase ("Resolving materials...");
mem_Compact ();
xrPhase_ResolveMaterials ();
IsolateVertices (TRUE);
//****************************************** UV mapping
{
FPU::m64r ();
Phase ("Build UV mapping...");
mem_Compact ();
xrPhase_UVmap ();
IsolateVertices (TRUE);
}
//****************************************** Subdivide geometry
FPU::m64r ();
Phase ("Subdividing geometry...");
mem_Compact ();
xrPhase_Subdivide ();
IsolateVertices (TRUE);
//****************************************** All lighting + lmaps building and saving
Light ();
//****************************************** Merge geometry
FPU::m64r ();
Phase ("Merging geometry...");
mem_Compact ();
xrPhase_MergeGeometry ();
//****************************************** Convert to OGF
FPU::m64r ();
Phase ("Converting to OGFs...");
mem_Compact ();
Flex2OGF ();
//****************************************** Wait for MU
FPU::m64r ();
Phase ("LIGHT: Waiting for MU-thread...");
mem_Compact ();
mu_base.wait (500);
mu_secondary.wait (500);
//****************************************** Export MU-models
FPU::m64r ();
Phase ("Converting MU-models to OGFs...");
mem_Compact ();
{
u32 m;
Status ("MU : Models...");
for (m=0; m<mu_models.size(); m++) {
mu_models[m]->calc_ogf ();
mu_models[m]->export_geometry ();
}
Status ("MU : References...");
for (m=0; m<mu_refs.size(); m++)
mu_refs[m]->export_ogf ();
}
//****************************************** Destroy RCast-model
FPU::m64r ();
Phase ("Destroying ray-trace model...");
mem_Compact ();
xr_delete (RCAST_Model);
//****************************************** Build sectors
FPU::m64r ();
Phase ("Building sectors...");
mem_Compact ();
BuildSectors ();
//****************************************** Saving MISC stuff
FPU::m64r ();
Phase ("Saving...");
mem_Compact ();
SaveLights (*fs);
fs->open_chunk (fsL_GLOWS);
for (u32 i=0; i<glows.size(); i++)
{
b_glow& G = glows[i];
fs->w (&G,4*sizeof(float));
string1024 sid;
strconcat (sid,
shader_render[materials[G.dwMaterial].shader].name,
"/",
textures [materials[G.dwMaterial].surfidx].name
);
fs->w_u16 (RegisterShader(sid));
}
fs->close_chunk ();
SaveTREE (*fs);
SaveSectors (*fs);
err_save ();
}
void CEditableObject::Save(IWriter& F)
{
F.open_chunk (EOBJ_CHUNK_VERSION);
F.w_u16 (EOBJ_CURRENT_VERSION);
F.close_chunk ();
F.open_chunk (EOBJ_CHUNK_CLASSSCRIPT);
F.w_stringZ (m_ClassScript);
F.close_chunk ();
F.open_chunk (EOBJ_CHUNK_LODS);
F.w_stringZ (m_LODs);
F.close_chunk ();
F.w_chunk (EOBJ_CHUNK_FLAGS,&m_Flags.flags,sizeof(m_Flags.flags));
// Log("1: ",F.tell());
// meshes
F.open_chunk (EOBJ_CHUNK_EDITMESHES);
int count = 0;
for(EditMeshIt m = m_Meshes.begin();m!=m_Meshes.end();m++){
F.open_chunk(count); count++;
(*m)->SaveMesh(F);
F.close_chunk();
}
F.close_chunk ();
// Log("2: ",F.tell());
// surfaces
F.open_chunk (EOBJ_CHUNK_SURFACES3);
F.w_u32 (m_Surfaces.size());
for (SurfaceIt sf_it=m_Surfaces.begin(); sf_it!=m_Surfaces.end(); sf_it++){
F.w_stringZ ((*sf_it)->_Name ());
F.w_stringZ ((*sf_it)->_ShaderName ());
F.w_stringZ ((*sf_it)->_ShaderXRLCName ());
F.w_stringZ ((*sf_it)->_GameMtlName ());
F.w_stringZ ((*sf_it)->_Texture ());
F.w_stringZ ((*sf_it)->_VMap ());
F.w_u32 ((*sf_it)->m_Flags.get ());
F.w_u32 ((*sf_it)->_FVF ());
F.w_u32 (1);
}
F.close_chunk ();
// Log("3: ",F.tell());
// bones
if (!m_Bones.empty()){
F.open_chunk (EOBJ_CHUNK_BONES2);
for (BoneIt b_it=m_Bones.begin(); b_it!=m_Bones.end(); b_it++){
F.open_chunk (b_it-m_Bones.begin());
(*b_it)->Save (F);
F.close_chunk ();
}
F.close_chunk ();
}
// Log("4: ",F.tell());
// skeleton motions
if (!m_SMotions.empty()){
F.open_chunk (EOBJ_CHUNK_SMOTIONS);
F.w_u32 (m_SMotions.size());
for (SMotionIt s_it=m_SMotions.begin(); s_it!=m_SMotions.end(); s_it++) (*s_it)->Save(F);
F.close_chunk ();
}
// skeleton motions refs
if (m_SMotionRefs.size()){
F.open_chunk (EOBJ_CHUNK_SMOTIONS2);
F.w_stringZ (m_SMotionRefs);
F.close_chunk ();
}
// Log("5: ",F.tell());
// bone parts
if (!m_BoneParts.empty()){
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);
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->c_str());
}
F.close_chunk ();
}
// Log("6: ",F.tell());
if (IsDynamic()){
F.open_chunk (EOBJ_CHUNK_ACTORTRANSFORM);
F.w_fvector3 (a_vPosition);
F.w_fvector3 (a_vRotate);
F.close_chunk ();
}
// Log("7: ",F.tell());
F.open_chunk (EOBJ_CHUNK_DESC);
F.w_stringZ (m_CreateName.c_str());
F.w (&m_CreateTime,sizeof(m_CreateTime));
F.w_stringZ (m_ModifName.c_str());
F.w (&m_ModifTime,sizeof(m_ModifTime));
F.close_chunk ();
// set modif desc
SetVersionToCurrent (FALSE, TRUE);
bOnModified = false;
}
