void CBlender_Particle::Save ( IWriter& fs )
{
IBlender::Save (fs);
// Blend mode
xrP_TOKEN::Item I;
xrPWRITE_PROP (fs,"Blending", xrPID_TOKEN, oBlend);
I.ID = 0; strcpy(I.str,"SET"); fs.w (&I,sizeof(I));
I.ID = 1; strcpy(I.str,"BLEND"); fs.w (&I,sizeof(I));
I.ID = 2; strcpy(I.str,"ADD"); fs.w (&I,sizeof(I));
I.ID = 3; strcpy(I.str,"MUL"); fs.w (&I,sizeof(I));
I.ID = 4; strcpy(I.str,"MUL_2X"); fs.w (&I,sizeof(I));
I.ID = 5; strcpy(I.str,"ALPHA-ADD"); fs.w (&I,sizeof(I));
// Params
xrPWRITE_PROP (fs,"Texture clamp",xrPID_BOOL, oClamp);
xrPWRITE_PROP (fs,"Alpha ref", xrPID_INTEGER, oAREF);
}
//static const u32 mb_sz = 0x1000000;
bool CMemoryWriter::save_to (LPCSTR fn)
{
IWriter* F = FS.w_open(fn);
if (F){
F->w (pointer(),size());
FS.w_close (F);
return true;
}
return false;
}
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 CALifeStorageManager::save (LPCSTR save_name, bool update_name)
{
strcpy_s (g_last_saved_game,sizeof(g_last_saved_game),save_name);
string_path save;
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);
#ifdef SCRIPT_VARS_STORAGE
g_ScriptVars.save (stream);
#endif
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)
strcpy (m_save_name,save);
}
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 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) );
}
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 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 CBone::SaveData(IWriter& F)
{
F.open_chunk (BONE_CHUNK_DEF);
F.w_stringZ (name);
F.close_chunk ();
F.open_chunk (BONE_CHUNK_MATERIAL);
F.w_stringZ (game_mtl);
F.close_chunk ();
F.open_chunk (BONE_CHUNK_SHAPE);
F.w (&shape,sizeof(SBoneShape));
F.close_chunk ();
F.open_chunk (BONE_CHUNK_FLAGS);
F.w_u32 (IK_data.ik_flags.get());
F.close_chunk ();
F.open_chunk (BONE_CHUNK_IK_JOINT);
F.w_u32 (IK_data.type);
F.w (IK_data.limits,sizeof(SJointLimit)*3);
F.w_float (IK_data.spring_factor);
F.w_float (IK_data.damping_factor);
F.close_chunk ();
F.open_chunk (BONE_CHUNK_IK_JOINT_BREAK);
F.w_float (IK_data.break_force);
F.w_float (IK_data.break_torque);
F.close_chunk ();
F.open_chunk (BONE_CHUNK_IK_JOINT_FRICTION);
F.w_float (IK_data.friction);
F.close_chunk ();
F.open_chunk (BONE_CHUNK_MASS);
F.w_float (mass);
F.w_fvector3 (center_of_mass);
F.close_chunk ();
}
//---------------------------------------------------------------------------------------
//copy/paste utils
//---------------------------------------------------------------------------------------
void EScene::SaveSelection( ObjClassID classfilter, LPCSTR fname )
{
VERIFY ( fname );
xr_string full_name;
full_name = fname;
IWriter* F = FS.w_open(full_name.c_str()); R_ASSERT(F);
F->open_chunk (CHUNK_VERSION);
F->w_u32 (CURRENT_FILE_VERSION);
F->close_chunk ();
m_SaveCache.clear();
if (OBJCLASS_DUMMY==classfilter)
{
SceneToolsMapPairIt _I = m_SceneTools.begin();
SceneToolsMapPairIt _E = m_SceneTools.end();
for (; _I!=_E; ++_I)
if (_I->second&&_I->second->IsNeedSave())
{
F->open_chunk (CHUNK_TOOLS_DATA+_I->first);
_I->second->SaveSelection (m_SaveCache);
F->w (m_SaveCache.pointer(),m_SaveCache.size());
m_SaveCache.clear ();
F->close_chunk ();
}
}else{
ESceneToolBase* mt = GetTool(classfilter); VERIFY(mt);
F->open_chunk (CHUNK_TOOLS_DATA+classfilter);
mt->SaveSelection(m_SaveCache);
F->w (m_SaveCache.pointer(),m_SaveCache.size());
m_SaveCache.clear();
F->close_chunk ();
}
FS.w_close (F);
}
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
}
// Represent a node as HierrarhyVisual
void OGF_Node::Save (IWriter &fs)
{
OGF_Base::Save (fs);
// Header
fs.open_chunk (OGF_HEADER);
ogf_header H;
H.format_version = xrOGF_FormatVersion;
H.type = MT_HIERRARHY;
H.shader_id = 0;
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 ();
// Children
fs.open_chunk (OGF_CHILDREN_L);
fs.w_u32 ((u32)chields.size());
fs.w (&*chields.begin(),(u32)chields.size()*sizeof(u32));
fs.close_chunk ();
}
void OGF::Save (IWriter &fs)
{
OGF_Base::Save (fs);
// clMsg ("* %d faces",faces.size());
geom_batch_average ((u32)vertices.size(),(u32)faces.size());
// Texture & shader
std::string Tname;
for (u32 i=0; i<textures.size(); i++) {
if (!Tname.empty()) Tname += ',';
string256 t;
strcpy (t,*textures[i].name);
if (strchr(t,'.')) *strchr(t,'.')=0;
Tname += t;
}
string1024 sid;
strconcat (sizeof(sid),sid,
pBuild->shader_render[pBuild->materials[material].shader].name,
"/",
Tname.c_str()
);
// Create header
ogf_header H;
H.format_version = xrOGF_FormatVersion;
H.type = m_SWI.count?MT_PROGRESSIVE:MT_NORMAL;
H.shader_id = RegisterShader (sid);
H.bb.min = bbox.min;
H.bb.max = bbox.max;
H.bs.c = C;
H.bs.r = R;
// Vertices
Shader_xrLC* SH = pBuild->shaders.Get (pBuild->materials[material].reserved);
bool bVertexColors = (SH->flags.bLIGHT_Vertex);
switch (H.type)
{
case MT_NORMAL :
case MT_PROGRESSIVE :
Save_Normal_PM (fs,H,bVertexColors);
break;
}
// Header
fs.open_chunk (OGF_HEADER);
fs.w (&H,sizeof(H));
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 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 ();
}
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 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 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 EScene::Save(LPCSTR map_name, bool bUndo, bool bForceSaveAll)
{
R_ASSERT (bUndo);
VERIFY (map_name);
CTimer T;
T.Start ();
xr_string full_name;
full_name = map_name;
xr_string part_prefix;
bool bSaveMain = true;
IWriter* F = 0;
if (bSaveMain)
{
F = FS.w_open(full_name.c_str()); R_ASSERT(F);
F->open_chunk (CHUNK_VERSION);
F->w_u32 (CURRENT_FILE_VERSION);
F->close_chunk ();
F->open_chunk (CHUNK_LEVELOP);
m_LevelOp.Save (*F);
F->close_chunk ();
F->open_chunk (CHUNK_TOOLS_GUID);
F->w (&m_GUID,sizeof(m_GUID));
F->close_chunk ();
F->open_chunk (CHUNK_LEVEL_TAG);
F->w_stringZ (m_OwnerName);
F->w (&m_CreateTime,sizeof(m_CreateTime));
F->close_chunk ();
F->open_chunk (CHUNK_CAMERA);
F->w_fvector3 (EDevice.m_Camera.GetHPB());
F->w_fvector3 (EDevice.m_Camera.GetPosition());
F->close_chunk ();
F->open_chunk (CHUNK_SNAPOBJECTS);
F->w_u32 (m_ESO_SnapObjects.size());
for(ObjectIt _F=m_ESO_SnapObjects.begin();_F!=m_ESO_SnapObjects.end();++_F)
F->w_stringZ ((*_F)->Name);
F->close_chunk ();
}
m_SaveCache.clear ();
SceneToolsMapPairIt _I = m_SceneTools.begin();
SceneToolsMapPairIt _E = m_SceneTools.end();
for (; _I!=_E; ++_I)
{
if ( (_I->first!=OBJCLASS_DUMMY) &&
_I->second &&
_I->second->IsEnabled() &&
_I->second->IsEditable() &&
(_I->second->IsChanged()||bForceSaveAll) )
{
if (_I->second->IsEnabled()&&_I->second->IsEditable())
{
if (_I->second->IsNeedSave())
{
_I->second->SaveStream (m_SaveCache);
F->open_chunk (CHUNK_TOOLS_DATA+_I->first);
F->w (m_SaveCache.pointer(),m_SaveCache.size());
F->close_chunk ();
}
}
m_SaveCache.clear ();
}
}
// save data
if (bSaveMain) FS.w_close(F);
}
void EScene::SaveLTX(LPCSTR map_name, bool bForUndo, bool bForceSaveAll)
{
VERIFY (map_name);
R_ASSERT (!bForUndo);
CTimer T;
T.Start ();
xr_string full_name;
full_name = map_name;
xr_string part_prefix;
bool bSaveMain = true;
if (!bForUndo)
{
if (bSaveMain)
{
EFS.MarkFile (full_name.c_str(),true);
}
part_prefix = LevelPartPath(full_name.c_str());
}
CInifile ini(full_name.c_str(),FALSE,FALSE,TRUE);
if (bSaveMain)
{
ini.w_u32 ("version","value",CURRENT_FILE_VERSION);
m_LevelOp.SaveLTX (ini);
m_GUID.SaveLTX (ini,"guid","guid");
ini.w_string ("level_tag","owner",m_OwnerName.c_str());
ini.w_u32 ("level_tag","create_time",m_CreateTime);
ini.w_fvector3 ("camera","hpb",EDevice.m_Camera.GetHPB());
ini.w_fvector3 ("camera","pos",EDevice.m_Camera.GetPosition());
for(ObjectIt SO=m_ESO_SnapObjects.begin(); SO!=m_ESO_SnapObjects.end(); ++SO)
{
ini.w_string ("snap_objects",(*SO)->Name,NULL);
}
}
m_SaveCache.clear ();
SceneToolsMapPairIt _I = m_SceneTools.begin();
SceneToolsMapPairIt _E = m_SceneTools.end();
for (; _I!=_E; ++_I)
{
if ( (_I->first!=OBJCLASS_DUMMY) &&
_I->second &&
_I->second->IsEnabled() &&
_I->second->IsEditable()
)
{
if (bForUndo)
{
if (_I->second->IsNeedSave())
_I->second->SaveStream (m_SaveCache);
}else
{
// !ForUndo
xr_string part_name = part_prefix + _I->second->ClassName() + ".part";
if(_I->second->can_use_inifile())
{
EFS.MarkFile (part_name.c_str(),true);
SaveToolLTX (_I->second->ClassID, part_name.c_str());
} //can_use_ini_file
else
{
_I->second->SaveStream (m_SaveCache);
EFS.MarkFile (part_name.c_str(),true);
IWriter* FF = FS.w_open (part_name.c_str());
R_ASSERT (FF);
FF->open_chunk (CHUNK_TOOLS_GUID);
FF->w (&m_GUID,sizeof(m_GUID));
FF->close_chunk ();
FF->open_chunk (CHUNK_TOOLS_DATA+_I->first);
FF->w (m_SaveCache.pointer(),m_SaveCache.size());
FF->close_chunk ();
FS.w_close (FF);
}// ! can_use_ini_file
}
m_SaveCache.clear ();
}
}
if (!bForUndo)
{
m_RTFlags.set (flRT_Unsaved,FALSE);
Msg ("Saving time: %3.2f sec",T.GetElapsed_sec());
}
}
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 CBuild::BuildCForm ()
{
// Collecting data
Phase ("CFORM: creating...");
vecFace* cfFaces = new vecFace();
vecVertex* cfVertices = new vecVertex();
{
xr_vector<bool> cfVertexMarks;
cfVertexMarks.assign (lc_global_data()->g_vertices().size(),false);
Status("Sorting...");
std::sort(lc_global_data()->g_vertices().begin(),lc_global_data()->g_vertices().end());
Status("Collecting faces...");
cfFaces->reserve (lc_global_data()->g_faces().size());
for (vecFaceIt I=lc_global_data()->g_faces().begin(); I!=lc_global_data()->g_faces().end(); ++I)
{
Face* F = *I;
if (F->Shader().flags.bCollision)
{
cfFaces->push_back(F);
int index = GetVertexIndex(F->v[0]);
cfVertexMarks[index] = true;
index = GetVertexIndex(F->v[1]);
cfVertexMarks[index] = true;
index = GetVertexIndex(F->v[2]);
cfVertexMarks[index] = true;
}
}
Status("Collecting vertices...");
cfVertices->reserve (lc_global_data()->g_vertices().size());
std::sort(cfFaces->begin(),cfFaces->end());
for (u32 V=0; V<lc_global_data()->g_vertices().size(); V++)
if (cfVertexMarks[V]) cfVertices->push_back(lc_global_data()->g_vertices()[V]);
}
float p_total = 0;
float p_cost = 1.f/(cfVertices->size());
Fbox BB; BB.invalidate();
for (vecVertexIt it = cfVertices->begin(); it!=cfVertices->end(); it++)
BB.modify((*it)->P );
// CForm
Phase ("CFORM: collision model...");
Status ("Items to process: %d", cfFaces->size());
p_total = 0;
p_cost = 1.f/(cfFaces->size());
// Collect faces
CDB::CollectorPacked CL (BB,cfVertices->size(),cfFaces->size());
for (vecFaceIt F = cfFaces->begin(); F!=cfFaces->end(); F++)
{
Face* T = *F;
TestEdge (T->v[0],T->v[1],T);
TestEdge (T->v[1],T->v[2],T);
TestEdge (T->v[2],T->v[0],T);
CL.add_face (
T->v[0]->P, T->v[1]->P, T->v[2]->P,
T->dwMaterialGame, materials()[T->dwMaterial].sector, T->sm_group
);
Progress(p_total+=p_cost); // progress
}
if (bCriticalErrCnt) {
err_save ();
clMsg ("MultipleEdges: %d faces",bCriticalErrCnt);
}
xr_delete (cfFaces);
xr_delete (cfVertices);
// Models
Status ("Models...");
for (u32 ref=0; ref<mu_refs().size(); ref++)
mu_refs()[ref]->export_cform_game(CL);
// Simplification
if (g_params().m_quality!=ebqDraft)
SimplifyCFORM (CL);
// bb?
BB.invalidate ();
for (size_t it = 0; it<CL.getVS(); it++)
BB.modify( CL.getV()[it] );
// Saving
string_path fn;
IWriter* MFS = FS.w_open (strconcat(sizeof(fn),fn,pBuild->path,"level.cform"));
Status ("Saving...");
// Header
hdrCFORM hdr;
hdr.version = CFORM_CURRENT_VERSION;
hdr.vertcount = (u32)CL.getVS();
hdr.facecount = (u32)CL.getTS();
hdr.aabb = BB;
MFS->w (&hdr,sizeof(hdr));
// Data
MFS->w (CL.getV(),(u32)CL.getVS()*sizeof(Fvector));
MFS->w (CL.getT(),(u32)CL.getTS()*sizeof(CDB::TRI));
// Clear pDeflector (it is stored in the same memory space with dwMaterialGame)
for (vecFaceIt I=lc_global_data()->g_faces().begin(); I!=lc_global_data()->g_faces().end(); I++)
{
Face* F = *I;
F->pDeflector = NULL;
}
FS.w_close (MFS);
}
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 ();
}
int ProcessDifference()
{
LPCSTR params = GetCommandLine();
Flags32 _flags;
_flags.zero();
if(strstr(params,"-diff /?")){
printf("HELP:\n");
printf("xrCompress.exe -diff <new_data> <old_data> -out <diff_resulf> [options]\n");
printf("<new_data>, <old_data> and <diff_resulf> values must be a folder name\n");
printf("[options] are set of:\n");
printf("-nofileage do not perform file age checking\n");
printf("-crc do not perform crc32 checking\n");
printf("-nobinary do not perform binary content checking\n");
printf("-nosize do not perform file size checking\n");
return 3;
}
CLocatorAPI* FS_new = NULL;
CLocatorAPI* FS_old = NULL;
xr_vector<char*>* file_list_old = NULL;
xr_vector<char*>* folder_list_old = NULL;
xr_vector<char*>* file_list_new = NULL;
xr_vector<char*>* folder_list_new = NULL;
sscanf (strstr(params,"-diff ")+6,"%[^ ] ",new_folder);
sscanf (strstr(params,"-diff ")+6+xr_strlen(new_folder)+1,"%[^ ] ",old_folder);
sscanf (strstr(params,"-out ")+5,"%[^ ] ",target_folder);
if(strstr(params,"-nofileage")){
_flags.set(file_comparer::eDontCheckFileAge, TRUE);
};
if(strstr(params,"-nocrc")){
_flags.set(file_comparer::eDontCheckCRC, TRUE);
};
if(strstr(params,"-nobinary")){
_flags.set(file_comparer::eDontCheckBinary, TRUE);
};
if(strstr(params,"-nosize")){
_flags.set(file_comparer::eDontCheckFileSize, TRUE);
};
FS_new = xr_new<CLocatorAPI> ();
FS_new->_initialize(CLocatorAPI::flTargetFolderOnly,new_folder);
file_list_new = FS_new->file_list_open ("$target_folder$",FS_ListFiles);
folder_list_new = FS_new->file_list_open ("$target_folder$",FS_ListFolders);
FS_old = xr_new<CLocatorAPI> ();
FS_old->_initialize(CLocatorAPI::flTargetFolderOnly,old_folder);
file_list_old = FS_old->file_list_open ("$target_folder$",FS_ListFiles);
folder_list_old = FS_old->file_list_open ("$target_folder$",FS_ListFolders);
xr_vector<LPCSTR> target_file_list;
target_file_list.reserve(file_list_new->size());
for(u32 i=0; i<file_list_new->size();++i){
file_comparer fc(file_list_new->at(i),FS_new, FS_old,_flags);
xr_vector<char*>::iterator it = std::find_if(file_list_old->begin(),file_list_old->end(),fc);
if(it != file_list_old->end()){
printf("skip file %s\n",file_list_new->at(i));
}else
target_file_list.push_back(file_list_new->at(i));
}
string_path out_path;
for(u32 i=0; i<target_file_list.size();++i){
LPCSTR fn = target_file_list[i];
strconcat(out_path,target_folder,"\\",fn);
VerifyPath(out_path);
IReader* r = FS_new->r_open("$target_folder$",fn);
IWriter* w = FS_old->w_open(out_path);
w->w(r->pointer(),r->length());
FS_new->r_close(r);
FS_old->w_close(w);
}
FS_new->file_list_close(file_list_new);
FS_new->file_list_close(folder_list_new);
FS_old->file_list_close(file_list_old);
FS_old->file_list_close(folder_list_old);
xr_delete(FS_new);
xr_delete(FS_old);
return 0;
}
void CBuild::BuildRapid (BOOL bSaveForOtherCompilers)
{
float p_total = 0;
float p_cost = 1.f/(g_faces.size());
xr_delete (RCAST_Model);
Status ("Converting faces...");
for (u32 fit=0; fit<g_faces.size(); fit++) g_faces[fit]->flags.bProcessed = false;
xr_vector<Face*> adjacent; adjacent.reserve(6*2*3);
CDB::CollectorPacked CL (scene_bb,g_vertices.size(),g_faces.size());
for (vecFaceIt it=g_faces.begin(); it!=g_faces.end(); it++)
{
Face* F = (*it);
Shader_xrLC& SH = F->Shader();
if (!SH.flags.bLIGHT_CastShadow) continue;
Progress (float(it-g_faces.begin())/float(g_faces.size()));
// Collect
adjacent.clear ();
for (int vit=0; vit<3; vit++)
{
Vertex* V = F->v[vit];
for (u32 adj=0; adj<V->adjacent.size(); adj++)
{
adjacent.push_back(V->adjacent[adj]);
}
}
std::sort (adjacent.begin(),adjacent.end());
adjacent.erase (std::unique(adjacent.begin(),adjacent.end()),adjacent.end());
// Unique
BOOL bAlready = FALSE;
for (u32 ait=0; ait<adjacent.size(); ait++)
{
Face* Test = adjacent[ait];
if (Test==F) continue;
if (!Test->flags.bProcessed) continue;
if (FaceEqual(*F,*Test)){
bAlready = TRUE;
break;
}
}
//
if (!bAlready)
{
F->flags.bProcessed = true;
#ifdef _WIN64
CL.add_face_D ( F->v[0]->P,F->v[1]->P,F->v[2]->P, *((u64*)&F) );
#else
CL.add_face_D ( F->v[0]->P,F->v[1]->P,F->v[2]->P, *((u32*)&F) );
#endif
}
}
/*
clMsg ("Faces: original(%d), model(%d), ratio(%f)",
g_faces.size(),CL.getTS(),float(CL.getTS())/float(g_faces.size()));
*/
// Export references
if (bSaveForOtherCompilers) Phase ("Building rcast-CFORM-mu model...");
Status ("Models...");
for (u32 ref=0; ref<mu_refs.size(); ref++)
mu_refs[ref]->export_cform_rcast (CL);
// "Building tree..
Status ("Building search tree...");
RCAST_Model = xr_new<CDB::MODEL> ();
RCAST_Model->build (CL.getV(),(int)CL.getVS(),CL.getT(),(int)CL.getTS());
extern void SaveAsSMF (LPCSTR fname, CDB::CollectorPacked& CL);
// save source SMF
string_path fn;
#ifdef PRIQUEL
bool keep_temp_files = !!strstr(Core.Params,"-keep_temp_files");
#endif // PRIQUEL
if (g_params.m_quality!=ebqDraft) {
#ifdef PRIQUEL
if (keep_temp_files)
#endif // PRIQUEL
SaveAsSMF (strconcat(sizeof(fn),fn,pBuild->path,"build_cform_source.smf"),CL);
}
// Saving for AI/DO usage
if (bSaveForOtherCompilers)
{
Status ("Saving...");
string_path fn;
IWriter* MFS = FS.w_open (strconcat(sizeof(fn),fn,pBuild->path,"build.cform"));
xr_vector<b_rc_face> rc_faces;
rc_faces.resize (CL.getTS());
// Prepare faces
for (u32 k=0; k<CL.getTS(); k++){
CDB::TRI* T = CL.getT()+k;
base_Face* F = (base_Face*)(*((void**)&T->dummy));
b_rc_face& cf = rc_faces[k];
cf.dwMaterial = F->dwMaterial;
cf.dwMaterialGame = F->dwMaterialGame;
Fvector2* cuv = F->getTC0 ();
cf.t[0].set (cuv[0]);
cf.t[1].set (cuv[1]);
cf.t[2].set (cuv[2]);
}
if (g_params.m_quality!=ebqDraft) {
#ifdef PRIQUEL
if (keep_temp_files)
#endif // PRIQUEL
SaveUVM (strconcat(sizeof(fn),fn,pBuild->path,"build_cform_source.uvm"),rc_faces);
}
MFS->open_chunk (0);
// Header
hdrCFORM hdr;
hdr.version = CFORM_CURRENT_VERSION;
hdr.vertcount = (u32)CL.getVS();
hdr.facecount = (u32)CL.getTS();
hdr.aabb = scene_bb;
MFS->w (&hdr,sizeof(hdr));
// Data
MFS->w (CL.getV(),(u32)CL.getVS()*sizeof(Fvector));
/* uncomment this in case of compatibility needs with old xrDO_Light
#ifdef _WIN64
size_t t_size = CL.getTS();
for (size_t i = 0; i < t_size; ++i)
{
CDB::TRI *tri = &(CL.getT()[i]);
MFS->w(&(tri->verts[0]), 12);
MFS->w_u32(tri->dummy_low);
}
#else*/
MFS->w (CL.getT(),(u32)CL.getTS()*sizeof(CDB::TRI));
//#endif
MFS->close_chunk ();
MFS->open_chunk (1);
MFS->w (&*rc_faces.begin(),(u32)rc_faces.size()*sizeof(b_rc_face));
MFS->close_chunk ();
}
}
/*
extern "C"
{
LPCSTR WINAPI D3DXGetPixelShaderProfile (LPDIRECT3DDEVICE9 pDevice);
LPCSTR WINAPI D3DXGetVertexShaderProfile (LPDIRECT3DDEVICE9 pDevice);
};
*/
HRESULT CRender::shader_compile (
LPCSTR name,
LPCSTR pSrcData,
UINT SrcDataLen,
void* _pDefines,
void* _pInclude,
LPCSTR pFunctionName,
LPCSTR pTarget,
DWORD Flags,
void* _ppShader,
void* _ppErrorMsgs,
void* _ppConstantTable)
{
D3DXMACRO defines [128];
int def_it = 0;
CONST D3DXMACRO* pDefines = (CONST D3DXMACRO*) _pDefines;
char c_smapsize [32];
char c_gloss [32];
// Msg("%s.%s", name, pTarget);
if (pDefines) {
// transfer existing defines
for (;; def_it++) {
if (0==pDefines[def_it].Name) break;
defines[def_it] = pDefines[def_it];
}
}
// options
{
sprintf (c_smapsize,"%d",u32(o.smapsize));
defines[def_it].Name = "SMAP_size";
defines[def_it].Definition = c_smapsize;
def_it ++ ;
}
if (o.fp16_filter) {
defines[def_it].Name = "FP16_FILTER";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.fp16_blend) {
defines[def_it].Name = "FP16_BLEND";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.HW_smap) {
defines[def_it].Name = "USE_HWSMAP";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.HW_smap_PCF) {
defines[def_it].Name = "USE_HWSMAP_PCF";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.HW_smap_FETCH4) {
defines[def_it].Name = "USE_FETCH4";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.sjitter) {
defines[def_it].Name = "USE_SJITTER";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (HW.Caps.raster_major >= 3) {
defines[def_it].Name = "USE_BRANCHING";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (HW.Caps.geometry.bVTF) {
defines[def_it].Name = "USE_VTF";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.Tshadows) {
defines[def_it].Name = "USE_TSHADOWS";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.mblur) {
defines[def_it].Name = "USE_MBLUR";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.sunfilter) {
defines[def_it].Name = "USE_SUNFILTER";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.sunstatic) {
defines[def_it].Name = "USE_R2_STATIC_SUN";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.forcegloss) {
sprintf (c_gloss,"%f",o.forcegloss_v);
defines[def_it].Name = "FORCE_GLOSS";
defines[def_it].Definition = c_gloss;
def_it ++ ;
}
if (o.forceskinw) {
defines[def_it].Name = "SKIN_COLOR";
defines[def_it].Definition = "1";
def_it ++;
}
// skinning
if (m_skinning<0) {
defines[def_it].Name = "SKIN_NONE";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (0==m_skinning) {
defines[def_it].Name = "SKIN_0";
defines[def_it].Definition = "1";
def_it ++;
}
if (1==m_skinning) {
defines[def_it].Name = "SKIN_1";
defines[def_it].Definition = "1";
def_it ++;
}
if (2==m_skinning) {
defines[def_it].Name = "SKIN_2";
defines[def_it].Definition = "1";
def_it ++;
}
// finish
defines[def_it].Name = 0;
defines[def_it].Definition = 0;
def_it ++;
//
if (0==xr_strcmp(pFunctionName,"main")) {
if ('v'==pTarget[0]) pTarget = D3DXGetVertexShaderProfile (HW.pDevice); // vertex "vs_2_a"; //
else pTarget = D3DXGetPixelShaderProfile (HW.pDevice); // pixel "ps_2_a"; //
}
LPD3DXINCLUDE pInclude = (LPD3DXINCLUDE) _pInclude;
LPD3DXBUFFER* ppShader = (LPD3DXBUFFER*) _ppShader;
LPD3DXBUFFER* ppErrorMsgs = (LPD3DXBUFFER*) _ppErrorMsgs;
LPD3DXCONSTANTTABLE* ppConstantTable = (LPD3DXCONSTANTTABLE*)_ppConstantTable;
#ifdef D3DXSHADER_USE_LEGACY_D3DX9_31_DLL // December 2006 and later
HRESULT _result = D3DXCompileShader(pSrcData,SrcDataLen,defines,pInclude,pFunctionName,pTarget,Flags|D3DXSHADER_USE_LEGACY_D3DX9_31_DLL,ppShader,ppErrorMsgs,ppConstantTable);
#else
HRESULT _result = D3DXCompileShader(pSrcData,SrcDataLen,defines,pInclude,pFunctionName,pTarget,Flags,ppShader,ppErrorMsgs,ppConstantTable);
#endif
if (SUCCEEDED(_result) && o.disasm)
{
ID3DXBuffer* code = *((LPD3DXBUFFER*)_ppShader);
ID3DXBuffer* disasm = 0;
D3DXDisassembleShader (LPDWORD(code->GetBufferPointer()), FALSE, 0, &disasm );
string_path dname;
strconcat (dname,"disasm\\",name,('v'==pTarget[0])?".vs":".ps" );
IWriter* W = FS.w_open("$logs$",dname);
W->w (disasm->GetBufferPointer(),disasm->GetBufferSize());
FS.w_close (W);
_RELEASE (disasm);
}
return _result;
}
void OGF_Reference::Save (IWriter &fs)
{
OGF_Base::Save (fs);
// geom_batch_average (vertices.size(),faces.size()); // don't use reference(s) as batch estimate
// Texture & shader
std::string Tname;
for (u32 i=0; i<textures.size(); i++)
{
if (!Tname.empty()) Tname += ',';
string256 t;
strcpy (t,*textures[i].name);
if (strchr(t,'.')) *strchr(t,'.')=0;
Tname += t;
}
string1024 sid ;
strconcat (sizeof(sid),sid,
pBuild->shader_render[pBuild->materials[material].shader].name,
"/",
Tname.c_str()
);
// Create header
ogf_header H;
H.format_version = xrOGF_FormatVersion;
H.type = model->m_SWI.count?MT_TREE_PM:MT_TREE_ST;
H.shader_id = RegisterShader (sid);
H.bb.min = bbox.min;
H.bb.max = bbox.max;
H.bs.c = C;
H.bs.r = R;
// Vertices
fs.open_chunk (OGF_GCONTAINER);
fs.w_u32 (vb_id);
fs.w_u32 (vb_start);
fs.w_u32 ((u32)model->vertices.size());
fs.w_u32 (ib_id);
fs.w_u32 (ib_start);
fs.w_u32 ((u32)model->faces.size()*3);
fs.close_chunk ();
// Special
fs.open_chunk (OGF_TREEDEF2);
fs.w (&xform, sizeof(xform));
fs.w (&c_scale, 5*sizeof(float));
fs.w (&c_bias, 5*sizeof(float));
fs.close_chunk ();
// Header
fs.open_chunk (OGF_HEADER);
fs.w (&H,sizeof(H));
fs.close_chunk ();
// progressive
if (H.type==MT_TREE_PM){
// SW
fs.open_chunk (OGF_SWICONTAINER);
fs.w_u32 (sw_id);
fs.close_chunk ();
}
}
static HRESULT create_shader (
LPCSTR const pTarget,
DWORD const* buffer,
u32 const buffer_size,
LPCSTR const file_name,
void*& result,
bool const disasm
)
{
HRESULT _result = E_FAIL;
if (pTarget[0] == 'p') {
SPS* sps_result = (SPS*)result;
_result = HW.pDevice->CreatePixelShader(buffer, &sps_result->ps);
if ( !SUCCEEDED(_result) ) {
Log ("! PS: ", file_name);
Msg ("! CreatePixelShader hr == 0x%08x", _result);
return E_FAIL;
}
LPCVOID data = NULL;
_result = D3DXFindShaderComment (buffer,MAKEFOURCC('C','T','A','B'),&data,NULL);
if (SUCCEEDED(_result) && data)
{
LPD3DXSHADER_CONSTANTTABLE pConstants = LPD3DXSHADER_CONSTANTTABLE(data);
sps_result->constants.parse (pConstants,0x1);
}
else
{
Log ("! PS: ", file_name);
Msg ("! D3DXFindShaderComment hr == 0x%08x", _result);
}
}
else {
SVS* svs_result = (SVS*)result;
_result = HW.pDevice->CreateVertexShader(buffer, &svs_result->vs);
if ( !SUCCEEDED(_result) ) {
Log ("! VS: ", file_name);
Msg ("! CreatePixelShader hr == 0x%08x", _result);
return E_FAIL;
}
LPCVOID data = NULL;
_result = D3DXFindShaderComment (buffer,MAKEFOURCC('C','T','A','B'),&data,NULL);
if (SUCCEEDED(_result) && data)
{
LPD3DXSHADER_CONSTANTTABLE pConstants = LPD3DXSHADER_CONSTANTTABLE(data);
svs_result->constants.parse (pConstants,0x2);
}
else
{
Log ("! VS: ", file_name);
Msg ("! D3DXFindShaderComment hr == 0x%08x", _result);
}
}
if (disasm)
{
ID3DXBuffer* disasm = 0;
D3DXDisassembleShader(LPDWORD(buffer), FALSE, 0, &disasm );
string_path dname;
strconcat (sizeof(dname),dname,"disasm\\",file_name,('v'==pTarget[0])?".vs":".ps" );
IWriter* W = FS.w_open("$logs$",dname);
W->w (disasm->GetBufferPointer(),disasm->GetBufferSize());
FS.w_close (W);
_RELEASE (disasm);
}
return _result;
}
HRESULT CRender::shader_compile (
LPCSTR name,
DWORD const* pSrcData,
UINT SrcDataLen,
LPCSTR pFunctionName,
LPCSTR pTarget,
DWORD Flags,
void*& result
)
{
D3DXMACRO defines [128];
int def_it = 0;
char sh_name[MAX_PATH] = "";
u32 len = 0;
// options
if (o.forceskinw) {
defines[def_it].Name = "SKIN_COLOR";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(o.forceskinw); ++len;
if (m_skinning<0) {
defines[def_it].Name = "SKIN_NONE";
defines[def_it].Definition = "1";
def_it ++;
sh_name[len]='1'; ++len;
}
else {
sh_name[len]='0'; ++len;
}
if (0==m_skinning) {
defines[def_it].Name = "SKIN_0";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(0==m_skinning); ++len;
if (1==m_skinning) {
defines[def_it].Name = "SKIN_1";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(1==m_skinning); ++len;
if (2==m_skinning) {
defines[def_it].Name = "SKIN_2";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(2==m_skinning); ++len;
if (3==m_skinning) {
defines[def_it].Name = "SKIN_3";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(3==m_skinning); ++len;
if (4==m_skinning) {
defines[def_it].Name = "SKIN_4";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(4==m_skinning); ++len;
// finish
defines[def_it].Name = 0;
defines[def_it].Definition = 0;
def_it ++;
R_ASSERT (def_it<128);
HRESULT _result = E_FAIL;
string_path folder_name, folder;
xr_strcpy ( folder, "r1\\objects\\r1\\" );
xr_strcat ( folder, name );
xr_strcat ( folder, "." );
char extension[3];
strncpy_s ( extension, pTarget, 2 );
xr_strcat ( folder, extension );
FS.update_path ( folder_name, "$game_shaders$", folder );
xr_strcat ( folder_name, "\\" );
m_file_set.clear( );
FS.file_list ( m_file_set, folder_name, FS_ListFiles | FS_RootOnly, "*");
string_path temp_file_name, file_name;
if ( !match_shader_id(name, sh_name, m_file_set, temp_file_name) ) {
string_path file;
xr_strcpy ( file, "shaders_cache\\r1\\" );
xr_strcat ( file, name );
xr_strcat ( file, "." );
xr_strcat ( file, extension );
xr_strcat ( file, "\\" );
xr_strcat ( file, sh_name );
FS.update_path ( file_name, "$app_data_root$", file);
}
else {
xr_strcpy ( file_name, folder_name );
xr_strcat ( file_name, temp_file_name );
}
if (FS.exist(file_name))
{
IReader* file = FS.r_open(file_name);
if (file->length()>4)
{
u32 crc = 0;
crc = file->r_u32();
boost::crc_32_type processor;
processor.process_block ( file->pointer(), ((char*)file->pointer()) + file->elapsed() );
u32 const real_crc = processor.checksum( );
if ( real_crc == crc ) {
_result = create_shader(pTarget, (DWORD*)file->pointer(), file->elapsed(), file_name, result, o.disasm);
}
}
file->close();
}
if (FAILED(_result))
{
includer Includer;
LPD3DXBUFFER pShaderBuf = NULL;
LPD3DXBUFFER pErrorBuf = NULL;
LPD3DXCONSTANTTABLE pConstants = NULL;
LPD3DXINCLUDE pInclude = (LPD3DXINCLUDE)&Includer;
_result = D3DXCompileShader((LPCSTR)pSrcData,SrcDataLen,defines,pInclude,pFunctionName,pTarget,Flags|D3DXSHADER_USE_LEGACY_D3DX9_31_DLL,&pShaderBuf,&pErrorBuf,&pConstants);
if (SUCCEEDED(_result)) {
IWriter* file = FS.w_open(file_name);
boost::crc_32_type processor;
processor.process_block ( pShaderBuf->GetBufferPointer(), ((char*)pShaderBuf->GetBufferPointer()) + pShaderBuf->GetBufferSize() );
u32 const crc = processor.checksum( );
file->w_u32 (crc);
file->w ( pShaderBuf->GetBufferPointer(), (u32)pShaderBuf->GetBufferSize());
FS.w_close (file);
_result = create_shader(pTarget, (DWORD*)pShaderBuf->GetBufferPointer(), pShaderBuf->GetBufferSize(), file_name, result, o.disasm);
}
else {
Log ("! ", file_name);
if ( pErrorBuf )
Log ("! error: ",(LPCSTR)pErrorBuf->GetBufferPointer());
else
Msg ("Can't compile shader hr=0x%08x", _result);
}
}
return _result;
}
