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; }