void TClipMaker::LoadClips() { bool bRes=true; if (EFS.GetOpenName("$clips$",m_ClipFName)){ Clear (); IReader* F = FS.r_open(m_ClipFName.c_str()); VERIFY(F); m_ClipFName = EFS.ExcludeBasePath(m_ClipFName.c_str(),FS.get_path("$clips$")->m_Path); if (F->find_chunk(CHUNK_ZOOM)){ m_Zoom = F->r_float(); } IReader* C = F->open_chunk(CHUNK_CLIPS); if(C){ IReader* M = C->open_chunk(0); for (int count=1; M; count++) { CUIClip* clip = xr_new<CUIClip>(this,count); if (!clip->Load(*M)){ ELog.Msg(mtError,"Unsupported clip version. Load failed."); xr_delete(clip); bRes = false; } M->close(); if (!bRes) break; clips.push_back(clip); M = C->open_chunk(count); } C->close (); UpdateClips (); } FS.r_close(F); } }
void ELightAnimLibrary::Load() { string_path fn; FS.update_path(fn,_game_data_,"lanims.xr"); IReader* fs=FS.r_open(fn); if (fs){ u16 version = 0; if (fs->find_chunk(CHUNK_VERSION)){ version = fs->r_u16(); } IReader* OBJ = fs->open_chunk(CHUNK_ITEM_LIST); if (OBJ){ IReader* O = OBJ->open_chunk(0); for (int count=1; O; count++) { CLAItem* I = xr_new<CLAItem>(); I->Load(*O); if (version==0){ for (CLAItem::KeyPairIt it=I->Keys.begin(); it!=I->Keys.end(); it++) it->second = subst_alpha(bgr2rgb(it->second),color_get_A(it->second)); } Items.push_back(I); O->close(); O = OBJ->open_chunk(count); } OBJ->close(); } FS.r_close(fs); } }
void CALifeSpawnRegistry::load (IReader &file_stream, xrGUID *save_guid) { IReader *chunk; chunk = file_stream.open_chunk(0); m_header.load (*chunk); chunk->close (); R_ASSERT2 (!save_guid || (*save_guid == header().guid()) || ignore_save_incompatibility(),"Saved game doesn't correspond to the spawn : DELETE SAVED GAME!"); chunk = file_stream.open_chunk(1); m_spawns.load (*chunk); chunk->close (); #if 0 SPAWN_GRAPH::vertex_iterator I = m_spawns.vertices().begin(); SPAWN_GRAPH::vertex_iterator E = m_spawns.vertices().end(); for ( ; I != E; ++I) { luabind::wrap_base *base = smart_cast<luabind::wrap_base*>(&(*I).second->data()->object()); if (!base) continue; if (xr_strcmp((*I).second->data()->object().name_replace(),"rostok_stalker_outfit")) continue; dummy *_dummy = (dummy*)((void*)base->m_self.m_impl); lua_State **_state = &_dummy->state; Msg ("0x%08x",*(int*)&_state); break; } #endif chunk = file_stream.open_chunk(2); load_data (m_artefact_spawn_positions,*chunk); chunk->close (); chunk = file_stream.open_chunk(3); R_ASSERT2 (chunk,"Spawn version mismatch - REBUILD SPAWN!"); ai().patrol_path_storage (*chunk); chunk->close (); VERIFY (!m_chunk); m_chunk = file_stream.open_chunk(4); R_ASSERT2 (m_chunk,"Spawn version mismatch - REBUILD SPAWN!"); VERIFY (!m_game_graph); m_game_graph = new CGameGraph(*m_chunk); ai().game_graph (m_game_graph); R_ASSERT2 ((header().graph_guid() == ai().game_graph().header().guid()) || ignore_save_incompatibility(),"Spawn doesn't correspond to the graph : REBUILD SPAWN!"); build_story_spawns (); build_root_spawns (); Msg ("* %d spawn points are successfully loaded",m_spawns.vertex_count()); }
void CPatrolPathStorage::load_raw (const CLevelGraph *level_graph, const CGameLevelCrossTable *cross, const CGameGraph *game_graph, IReader &stream) { IReader *chunk = stream.open_chunk(WAY_PATROLPATH_CHUNK); if (!chunk) return; u32 chunk_iterator; for (IReader *sub_chunk = chunk->open_chunk_iterator(chunk_iterator); sub_chunk; sub_chunk = chunk->open_chunk_iterator(chunk_iterator,sub_chunk)) { R_ASSERT (sub_chunk->find_chunk(WAYOBJECT_CHUNK_VERSION)); R_ASSERT (sub_chunk->r_u16() == WAYOBJECT_VERSION); R_ASSERT (sub_chunk->find_chunk(WAYOBJECT_CHUNK_NAME)); shared_str patrol_name; sub_chunk->r_stringZ (patrol_name); const_iterator I = m_registry.find(patrol_name); VERIFY3 (I == m_registry.end(),"Duplicated patrol path found",*patrol_name); m_registry.insert ( std::make_pair( patrol_name, &xr_new<CPatrolPath>( patrol_name )->load_raw( level_graph, cross, game_graph, *sub_chunk ) ) ); } chunk->close (); }
bool ESceneLightTools::Load(IReader& F) { u16 version = 0; if(F.r_chunk(CHUNK_VERSION,&version)) if( version!=LIGHT_TOOLS_VERSION ){ ELog.DlgMsg( mtError, "%s tools: Unsupported version.",ClassDesc()); return false; } if (!inherited::Load(F)) return false; if (F.find_chunk(CHUNK_FLAGS)) m_Flags.assign (F.r_u32()); if (F.find_chunk(CHUNK_SUN_SHADOW)){ F.r_u8 (); F.r_fvector2 (m_SunShadowDir); } if (F.find_chunk(CHUNK_LCONTROLS_LAST)) lcontrol_last_idx = F.r_u32(); IReader* R = F.open_chunk(CHUNK_LCONTROLS); if (R){ while (!R->eof()){ shared_str l_name; R->r_stringZ(l_name); u32 l_idx = R->r_u32(); AppendLightControl(l_name.c_str(),&l_idx); } R->close (); } return true; }
/* void dump (CDetailManager::vis_list& lst) { for (int i=0; i<lst.size(); i++) { Msg("%8x / %8x / %8x", lst[i]._M_start, lst[i]._M_finish, lst[i]._M_end_of_storage._M_data); } } */ void CDetailManager::Load () { // Open file stream if (!FS.exist("$level$","level.details")) { dtFS = NULL; return; } string256 fn; FS.update_path (fn,"$level$","level.details"); dtFS = FS.r_open(fn); // Header dtFS->r_chunk_safe (0,&dtH,sizeof(dtH)); R_ASSERT (dtH.version == DETAIL_VERSION); u32 m_count = dtH.object_count; // Models IReader* m_fs = dtFS->open_chunk(1); for (u32 m_id = 0; m_id < m_count; m_id++) { CDetail* dt = xr_new<CDetail> (); IReader* S = m_fs->open_chunk(m_id); dt->Load (S); objects.push_back (dt); S->close (); } m_fs->close (); // Get pointer to database (slots) IReader* m_slots = dtFS->open_chunk(2); dtSlots = (DetailSlot*)m_slots->pointer(); m_slots->close (); // Initialize 'vis' and 'cache' for (u32 i=0; i<3; ++i) visible[i].resize(objects.size()); cache_Initialize (); // Make dither matrix bwdithermap (2,dither); // Hardware specific optimizations if (UseVS()) hw_Load (); else soft_Load (); // swing desc // normal swing_desc[0].amp1 = pSettings->r_float("details","swing_normal_amp1"); swing_desc[0].amp2 = pSettings->r_float("details","swing_normal_amp2"); swing_desc[0].rot1 = pSettings->r_float("details","swing_normal_rot1"); swing_desc[0].rot2 = pSettings->r_float("details","swing_normal_rot2"); swing_desc[0].speed = pSettings->r_float("details","swing_normal_speed"); // fast swing_desc[1].amp1 = pSettings->r_float("details","swing_fast_amp1"); swing_desc[1].amp2 = pSettings->r_float("details","swing_fast_amp2"); swing_desc[1].rot1 = pSettings->r_float("details","swing_fast_rot1"); swing_desc[1].rot2 = pSettings->r_float("details","swing_fast_rot2"); swing_desc[1].speed = pSettings->r_float("details","swing_fast_speed"); }
void FHierrarhyVisual::Load(const char* N, IReader *data, u32 dwFlags) { dxRender_Visual::Load(N,data,dwFlags); if (data->find_chunk(OGF_CHILDREN_L)) { // From Link u32 cnt = data->r_u32 (); children.resize (cnt); for (u32 i=0; i<cnt; i++) { #ifdef _EDITOR THROW; #else u32 ID = data->r_u32(); children[i] = (dxRender_Visual*)::Render->getVisual(ID); #endif } bDontDelete = TRUE; } else { if (data->find_chunk(OGF_CHILDREN)) { // From stream IReader* OBJ = data->open_chunk(OGF_CHILDREN); if (OBJ){ IReader* O = OBJ->open_chunk(0); for (int count=1; O; count++) { string_path name_load,short_name,num; xr_strcpy (short_name,N); if (strext(short_name)) *strext(short_name)=0; strconcat (sizeof(name_load),name_load,short_name,":",itoa(count,num,10)); children.push_back ((dxRender_Visual*)::Render->model_CreateChild(name_load,O)); O->close (); O = OBJ->open_chunk (count); } OBJ->close(); } bDontDelete = FALSE; } else { FATAL ("Invalid visual"); } } }
bool CPSLibrary::Load(const char* nm) { IReader* F = FS.r_open(nm); bool bRes = true; R_ASSERT(F->find_chunk(PS_CHUNK_VERSION)); u16 ver = F->r_u16(); if (ver!=PS_VERSION) return false; // second generation IReader* OBJ; OBJ = F->open_chunk(PS_CHUNK_SECONDGEN); if (OBJ){ IReader* O = OBJ->open_chunk(0); for (int count=1; O; count++) { PS::CPEDef* def = xr_new<PS::CPEDef>(); if (def->Load(*O)) m_PEDs.push_back(def); else{ bRes = false; xr_delete(def); } O->close(); if (!bRes) break; O = OBJ->open_chunk(count); } OBJ->close(); } // second generation OBJ = F->open_chunk(PS_CHUNK_THIRDGEN); if (OBJ){ IReader* O = OBJ->open_chunk(0); for (int count=1; O; count++) { PS::CPGDef* def = xr_new<PS::CPGDef>(); if (def->Load(*O)) m_PGDs.push_back(def); else{ bRes = false; xr_delete(def); } O->close(); if (!bRes) break; O = OBJ->open_chunk(count); } OBJ->close(); } // final FS.r_close (F); std::sort (m_PEDs.begin(),m_PEDs.end(),ped_sort_pred); std::sort (m_PGDs.begin(),m_PGDs.end(),pgd_sort_pred); return bRes; }
void CHOM::Load () { // Find and open file string_path fName; FS.update_path (fName,"$level$","level.hom"); if (!FS.exist(fName)) { Msg (" WARNING: Occlusion map '%s' not found.",fName); return; } Msg ("* Loading HOM: %s",fName); IReader* fs = FS.r_open(fName); IReader* S = fs->open_chunk(1); // Load tris and merge them CDB::Collector CL; while (!S->eof()) { HOM_poly P; S->r (&P,sizeof(P)); CL.add_face_packed_D (P.v1,P.v2,P.v3,P.flags,0.01f); } // Determine adjacency xr_vector<u32> adjacency; CL.calc_adjacency (adjacency); // Create RASTER-triangles m_pTris = xr_alloc<occTri> (u32(CL.getTS())); for (u32 it=0; it<CL.getTS(); it++) { CDB::TRI& clT = CL.getT()[it]; occTri& rT = m_pTris[it]; Fvector& v0 = CL.getV()[clT.verts[0]]; Fvector& v1 = CL.getV()[clT.verts[1]]; Fvector& v2 = CL.getV()[clT.verts[2]]; rT.adjacent[0] = (0xffffffff==adjacency[3*it+0])?((occTri*) (-1)):(m_pTris+adjacency[3*it+0]); rT.adjacent[1] = (0xffffffff==adjacency[3*it+1])?((occTri*) (-1)):(m_pTris+adjacency[3*it+1]); rT.adjacent[2] = (0xffffffff==adjacency[3*it+2])?((occTri*) (-1)):(m_pTris+adjacency[3*it+2]); rT.flags = clT.dummy; rT.area = Area (v0,v1,v2); if (rT.area<EPS_L) { Msg ("! Invalid HOM triangle (%f,%f,%f)-(%f,%f,%f)-(%f,%f,%f)",VPUSH(v0),VPUSH(v1),VPUSH(v2)); } rT.plane.build (v0,v1,v2); rT.skip = 0; rT.center.add(v0,v1).add(v2).div(3.f); } // Create AABB-tree m_pModel = xr_new<CDB::MODEL> (); m_pModel->build (CL.getV(),int(CL.getVS()),CL.getT(),int(CL.getTS())); bEnabled = TRUE; S->close (); FS.r_close (fs); }
void transfer(const char *name, xr_vector<T> &dest, IReader& F, u32 chunk) { IReader* O = F.open_chunk(chunk); u32 count = O?(O->length()/sizeof(T)):0; clMsg ("* %16s: %d",name,count); if (count) { dest.reserve(count); dest.insert (dest.begin(), (T*)O->pointer(), (T*)O->pointer() + count); } if (O) O->close (); }
void CPatrolPathStorage::load (IReader &stream) { IReader *chunk; chunk = stream.open_chunk(0); u32 size = chunk->r_u32(); chunk->close (); m_registry.clear (); PATROL_REGISTRY::value_type pair; chunk = stream.open_chunk(1); for (u32 i=0; i<size; ++i) { IReader *chunk1; chunk1 = chunk->open_chunk(i); IReader *chunk2; chunk2 = chunk1->open_chunk(0); load_data (pair.first,*chunk2); chunk2->close (); chunk2 = chunk1->open_chunk(1); load_data (pair.second,*chunk2); chunk2->close (); chunk1->close (); const_iterator I = m_registry.find(pair.first); VERIFY3 (I == m_registry.end(),"Duplicated patrol path found ",*pair.first); #ifdef DEBUG pair.second->name (pair.first); #endif m_registry.insert (pair); } chunk->close (); }
bool EDetailManager::LoadColorIndices(IReader& F) { VERIFY (objects.empty()); VERIFY (m_ColorIndices.empty()); bool bRes = true; // objects IReader* OBJ = F.open_chunk(DETMGR_CHUNK_OBJECTS); if (OBJ){ IReader* O = OBJ->open_chunk(0); for (int count=1; O; count++) { EDetail* DO = xr_new<EDetail>(); if (DO->Load(*O)) objects.push_back(DO); else bRes = false; O->close(); O = OBJ->open_chunk(count); } OBJ->close(); } // color index map R_ASSERT (F.find_chunk(DETMGR_CHUNK_COLOR_INDEX)); int cnt = F.r_u8(); string256 buf; u32 index; int ref_cnt; for (int k=0; k<cnt; k++){ index = F.r_u32(); ref_cnt = F.r_u8(); for (int j=0; j<ref_cnt; j++){ F.r_stringZ (buf,sizeof(buf)); EDetail* DO = FindDOByName(buf); if (DO) m_ColorIndices[index].push_back(DO); else bRes=false; } } InvalidateCache (); return bRes; }
bool EScene::LoadSelection( LPCSTR fname ) { u32 version = 0; VERIFY( fname ); xr_string full_name; full_name = fname; ELog.Msg( mtInformation, "EScene: loading part %s...", fname ); bool res = true; if (FS.exist(full_name.c_str())){ SelectObjects( false ); IReader* F = FS.r_open(full_name.c_str()); // Version R_ASSERT(F->r_chunk(CHUNK_VERSION, &version)); if (version!=CURRENT_FILE_VERSION){ ELog.DlgMsg( mtError, "EScene: unsupported file version. Can't load Level."); UI->UpdateScene(); FS.r_close(F); return false; } // Objects if (!ReadObjectsStream(*F,CHUNK_OBJECT_LIST,OnLoadSelectionAppendObject,0)) { ELog.DlgMsg(mtError,"EScene. Failed to load selection."); res = false; } SceneToolsMapPairIt _I = m_SceneTools.begin(); SceneToolsMapPairIt _E = m_SceneTools.end(); for (; _I!=_E; _I++) if (_I->second&&_I->second->IsEnabled()&&_I->second->IsEditable()){ IReader* chunk = F->open_chunk(CHUNK_TOOLS_DATA+_I->first); if (chunk){ _I->second->LoadSelection(*chunk); chunk->close (); } } // Synchronize SynchronizeObjects(); FS.r_close(F); } return res; }
bool EScene::ReadObjectStream(IReader& F, CCustomObject*& O) { ObjClassID clsid =OBJCLASS_DUMMY; R_ASSERT (F.find_chunk(CHUNK_OBJECT_CLASS)); clsid = ObjClassID(F.r_u32()); O = GetOTool(clsid)->CreateObject(0,0); IReader* S = F.open_chunk(CHUNK_OBJECT_BODY); R_ASSERT (S); bool bRes = O->LoadStream(*S); S->close (); if (!bRes) xr_delete (O); return bRes; }
bool CEditableObject::LoadObject(const char* fname) { if (FS.exist(fname)){ int age = FS.get_file_age (fname); VERIFY3(age>0,"Invalid file age:",fname); IReader* F = FS.r_open (fname); R_ASSERT(F); IReader* OBJ = F->open_chunk (EOBJ_CHUNK_OBJECT_BODY); R_ASSERT2 (OBJ,"Corrupted file."); bool bRes = Load(*OBJ); OBJ->close(); FS.r_close(F); if (bRes){ m_LoadName = fname; m_ObjectVersion = age; } return bRes; } return false; }
void CRender::LoadVisuals(IReader *fs) { IReader* chunk = 0; u32 index = 0; dxRender_Visual* V = 0; ogf_header H; while ((chunk=fs->open_chunk(index))!=0) { chunk->r_chunk_safe (OGF_HEADER,&H,sizeof(H)); V = Models->Instance_Create (H.type); V->Load(0,chunk,0); Visuals.push_back(V); chunk->close(); index++; } }
BOOL EScene::LoadLevelPart(ESceneToolBase* M, LPCSTR map_name) { if(M->can_use_inifile()) return LoadLevelPartLTX(M, map_name); if (FS.exist(map_name)) { // check locking M->m_EditFlags.set(ESceneToolBase::flReadonly,FALSE); IReader* R = FS.r_open (map_name); VERIFY (R); // check level part GUID R_ASSERT (R->find_chunk (CHUNK_TOOLS_GUID)); xrGUID guid; R->r (&guid,sizeof(guid)); if (guid!=m_GUID) { ELog.DlgMsg (mtError,"Skipping invalid version of level part: '%s\\%s.part'",EFS.ExtractFileName(map_name).c_str(),M->ClassName()); FS.r_close (R); return FALSE; } // read data IReader* chunk = R->open_chunk (CHUNK_TOOLS_DATA+M->ClassID); if(chunk!=NULL) { M->LoadStream (*chunk); chunk->close (); }else { ELog.DlgMsg (mtError,"Skipping corrupted version of level part: '%s\\%s.part'",EFS.ExtractFileName(map_name).c_str(),M->ClassName()); FS.r_close (R); return FALSE; } //success FS.r_close (R); return TRUE; } return TRUE; }
bool EScene::Load(LPCSTR map_name, bool bUndo) { u32 version = 0; if (!map_name||(0==map_name[0])) return false; xr_string full_name; full_name = map_name; ELog.Msg( mtInformation, "EScene: loading '%s'", map_name); if (FS.exist(full_name.c_str())) { CTimer T; T.Start(); // read main level IReader* F = FS.r_open(full_name.c_str()); VERIFY(F); // Version R_ASSERT (F->r_chunk(CHUNK_VERSION, &version)); if (version!=CURRENT_FILE_VERSION) { ELog.DlgMsg( mtError, "EScene: unsupported file version. Can't load Level."); UI->UpdateScene(); FS.r_close(F); return false; } // Lev. ops. IReader* LOP = F->open_chunk(CHUNK_LEVELOP); if (LOP) { m_LevelOp.Read (*LOP); LOP->close (); }else { ELog.DlgMsg (mtError, "Skipping old version of level options.\nCheck level options after loading."); } // if (F->find_chunk(CHUNK_CAMERA)) { Fvector hpb, pos; F->r_fvector3 (hpb); F->r_fvector3 (pos); EDevice.m_Camera.Set(hpb,pos); EDevice.m_Camera.SetStyle(EDevice.m_Camera.GetStyle()); } if (F->find_chunk(CHUNK_TOOLS_GUID)) { F->r (&m_GUID,sizeof(m_GUID)); } if (F->find_chunk(CHUNK_LEVEL_TAG)) { F->r_stringZ (m_OwnerName); F->r (&m_CreateTime,sizeof(m_CreateTime)); }else { m_OwnerName = ""; m_CreateTime = 0; } DWORD obj_cnt = 0; if (F->find_chunk(CHUNK_OBJECT_COUNT)) obj_cnt = F->r_u32(); SPBItem* pb = UI->ProgressStart(obj_cnt,"Loading objects..."); ReadObjectsStream (*F,CHUNK_OBJECT_LIST,OnLoadAppendObject,pb); UI->ProgressEnd (pb); SceneToolsMapPairIt _I = m_SceneTools.begin(); SceneToolsMapPairIt _E = m_SceneTools.end(); for (; _I!=_E; ++_I) { if (_I->second) { IReader* chunk = F->open_chunk(CHUNK_TOOLS_DATA+_I->first); if (chunk){ _I->second->LoadStream(*chunk); chunk->close (); }else{ if (!bUndo && _I->second->IsEnabled() && (_I->first!=OBJCLASS_DUMMY)) { LoadLevelPart (_I->second,LevelPartName(map_name,_I->first).c_str()); } } } } // snap list if (F->find_chunk(CHUNK_SNAPOBJECTS)) { shared_str buf; int cnt = F->r_u32(); if (cnt) { for (int i=0; i<cnt; ++i) { F->r_stringZ (buf); CCustomObject* O = FindObjectByName(buf.c_str(),OBJCLASS_SCENEOBJECT); if (!O) ELog.Msg(mtError,"EScene: Can't find snap object '%s'.",buf.c_str()); else m_ESO_SnapObjects.push_back(O); } } UpdateSnapList(); } Msg("EScene: %d objects loaded, %3.2f sec", ObjCount(), T.GetElapsed_sec() ); UI->UpdateScene(true); FS.r_close(F); SynchronizeObjects(); if (!bUndo) m_RTFlags.set(flRT_Unsaved|flRT_Modified,FALSE); return true; }else { ELog.Msg(mtError,"Can't find file: '%s'",map_name); } return false; }
bool EScene::ReadObjectsStream(IReader& F, u32 chunk_id, TAppendObject on_append, SPBItem* pb) { R_ASSERT (on_append); bool bRes = true; IReader* OBJ = F.open_chunk(chunk_id); if (OBJ) { IReader* O = OBJ->open_chunk(0); for (int count=1; O; ++count) { CCustomObject* obj =NULL; if (ReadObjectStream(*O, obj)) { LPCSTR obj_name = obj->Name; CCustomObject* existing = FindObjectByName(obj_name,obj->ClassID); if(existing) { if(g_frmConflictLoadObject->m_result!=2 && g_frmConflictLoadObject->m_result!=4 && g_frmConflictLoadObject->m_result!=6) { g_frmConflictLoadObject->m_existing_object = existing; g_frmConflictLoadObject->m_new_object = obj; g_frmConflictLoadObject->Prepare (); g_frmConflictLoadObject->ShowModal (); } switch(g_frmConflictLoadObject->m_result) { case 1: //Overwrite case 2: //Overwrite All { bool res = RemoveObject (existing, true, true); if(!res) Msg("! RemoveObject [%s] failed", existing->Name); else xr_delete(existing); }break; case 3: //Insert new case 4: //Insert new All { string256 buf; GenObjectName (obj->ClassID, buf, obj->Name); obj->Name = buf; }break; case 0: //Cancel case 5: //Skip case 6: //Skip All { xr_delete(obj); }break; } } if (obj && !on_append(obj)) xr_delete(obj);} else bRes = false; O->close (); O = OBJ->open_chunk(count); if (pb) pb->Inc(); } OBJ->close(); } return bRes; }
void game_sv_GameState::Create (shared_str &options) { string_path fn_game; m_item_respawner.clear_respawns(); if (FS.exist(fn_game, "$level$", "level.game")) { IReader *F = FS.r_open (fn_game); IReader *O = 0; // Load RPoints if (0!=(O = F->open_chunk (RPOINT_CHUNK))) { for (int id=0; O->find_chunk(id); ++id) { RPoint R; u8 team; u8 type; u16 GameType; shared_str rp_profile; O->r_fvector3 (R.P); O->r_fvector3 (R.A); team = O->r_u8 (); type = O->r_u8 (); GameType = O->r_u16 (); if(type==rptItemSpawn) O->r_stringZ (rp_profile); if (GameType != EGameIDs(u16(-1))) { if ((Type() == eGameIDCaptureTheArtefact) && (GameType & eGameIDCaptureTheArtefact)) { team = team - 1; R_ASSERT2( ((team >= 0) && (team < 4)) || (type != rptActorSpawn), "Problem with CTA Team indexes. Propably you have added rpoint of team 0 for cta game type."); } if ((!(GameType & eGameIDDeathmatch) && (Type() == eGameIDDeathmatch)) || (!(GameType & eGameIDTeamDeathmatch) && (Type() == eGameIDTeamDeathmatch)) || (!(GameType & eGameIDArtefactHunt) && (Type() == eGameIDArtefactHunt)) || (!(GameType & eGameIDCaptureTheArtefact) && (Type() == eGameIDCaptureTheArtefact)) ) { continue; }; }; switch (type) { case rptActorSpawn: { rpoints[team].push_back (R); for (int i=0; i<int(rpoints[team].size())-1; i++) { RPoint rp = rpoints[team][i]; float dist = R.P.distance_to_xz(rp.P)/2; if (dist<rpoints_MinDist[team]) rpoints_MinDist[team] = dist; dist = R.P.distance_to(rp.P)/2; if (dist<rpoints_Dist[team]) rpoints_Dist[team] = dist; }; }break; case rptItemSpawn: { m_item_respawner.add_new_rpoint(rp_profile, R); } }; }; O->close(); } FS.r_close (F); } if (!g_dedicated_server) { // loading scripts ai().script_engine().remove_script_process(ScriptEngine::eScriptProcessorGame); string_path S; FS.update_path (S,"$game_config$","script.ltx"); CInifile *l_tpIniFile = xr_new<CInifile>(S); R_ASSERT (l_tpIniFile); if( l_tpIniFile->section_exist( type_name() ) ) if (l_tpIniFile->r_string(type_name(),"script")) ai().script_engine().add_script_process(ScriptEngine::eScriptProcessorGame,xr_new<CScriptProcess>("game",l_tpIniFile->r_string(type_name(),"script"))); else ai().script_engine().add_script_process(ScriptEngine::eScriptProcessorGame,xr_new<CScriptProcess>("game","")); xr_delete (l_tpIniFile); } //--------------------------------------------------------------------- ConsoleCommands_Create(); //--------------------------------------------------------------------- // CCC_LoadCFG_custom* pTmp = xr_new<CCC_LoadCFG_custom>("sv_"); // pTmp->Execute (Console->ConfigFile); // xr_delete (pTmp); //--------------------------------------------------------------------- LPCSTR svcfg_ltx_name = "-svcfg "; if (strstr(Core.Params, svcfg_ltx_name)) { string_path svcfg_name = ""; int sz = xr_strlen(svcfg_ltx_name); sscanf (strstr(Core.Params,svcfg_ltx_name)+sz,"%[^ ] ",svcfg_name); // if (FS.exist(svcfg_name)) { Console->ExecuteScript(svcfg_name); } }; //--------------------------------------------------------------------- ReadOptions(options); }
void global_claculation_data::xrLoad() { string_path N; FS.update_path ( N, "$game_data$", "shaders_xrlc.xr" ); g_shaders_xrlc = new Shader_xrLC_LIB(); g_shaders_xrlc->Load ( N ); // Load CFORM { FS.update_path (N,"$level$","build.cform"); IReader* fs = FS.r_open("$level$","build.cform"); R_ASSERT (fs->find_chunk(0)); hdrCFORM H; fs->r (&H,sizeof(hdrCFORM)); R_ASSERT (CFORM_CURRENT_VERSION==H.version); Fvector* verts = (Fvector*)fs->pointer(); CDB::TRI* tris = (CDB::TRI*)(verts+H.vertcount); RCAST_Model.build ( verts, H.vertcount, tris, H.facecount ); Msg("* Level CFORM: %dK",RCAST_Model.memory()/1024); g_rc_faces.resize (H.facecount); R_ASSERT(fs->find_chunk(1)); fs->r (&*g_rc_faces.begin(),g_rc_faces.size()*sizeof(b_rc_face)); LevelBB.set (H.aabb); } { slots_data.Load( ); } // Lights { IReader* fs = FS.r_open("$level$","build.lights"); IReader* F; u32 cnt; R_Light* L; // rgb F = fs->open_chunk (0); cnt = F->length()/sizeof(R_Light); L = (R_Light*)F->pointer(); g_lights.rgb.assign (L,L+cnt); F->close (); // hemi F = fs->open_chunk (1); cnt = F->length()/sizeof(R_Light); L = (R_Light*)F->pointer(); g_lights.hemi.assign(L,L+cnt); F->close (); // sun F = fs->open_chunk (2); cnt = F->length()/sizeof(R_Light); L = (R_Light*)F->pointer(); g_lights.sun.assign (L,L+cnt); F->close (); FS.r_close (fs); } // Load level data { IReader* fs = FS.r_open ("$level$","build.prj"); IReader* F; // Version u32 version; fs->r_chunk (EB_Version,&version); R_ASSERT(XRCL_CURRENT_VERSION==version); // Header fs->r_chunk (EB_Parameters,&g_params); // Load level data transfer("materials", g_materials, *fs, EB_Materials); transfer("shaders_xrlc",g_shader_compile, *fs, EB_Shaders_Compile); post_process_materials( *g_shaders_xrlc, g_shader_compile, g_materials ); // process textures #ifdef DEBUG xr_vector<b_texture> dbg_textures; #endif Status ("Processing textures..."); { Surface_Init (); F = fs->open_chunk (EB_Textures); u32 tex_count = F->length()/sizeof(b_texture); for (u32 t=0; t<tex_count; t++) { Progress (float(t)/float(tex_count)); b_texture TEX; F->r (&TEX,sizeof(TEX)); #ifdef DEBUG dbg_textures.push_back( TEX ); #endif b_BuildTexture BT; CopyMemory (&BT,&TEX,sizeof(TEX)); // load thumbnail LPSTR N = BT.name; if (strchr(N,'.')) *(strchr(N,'.')) = 0; strlwr (N); if (0==xr_strcmp(N,"level_lods")) { // HACK for merged lod textures BT.dwWidth = 1024; BT.dwHeight = 1024; BT.bHasAlpha= TRUE; BT.pSurface = 0; } else { strcat (N,".thm"); IReader* THM = FS.r_open("$game_textures$",N); R_ASSERT2 (THM, N); // version u32 version = 0; R_ASSERT (THM->r_chunk(THM_CHUNK_VERSION,&version)); // if( version!=THM_CURRENT_VERSION ) FATAL ("Unsupported version of THM file."); // analyze thumbnail information R_ASSERT(THM->find_chunk(THM_CHUNK_TEXTUREPARAM)); THM->r (&BT.THM.fmt,sizeof(STextureParams::ETFormat)); BT.THM.flags.assign (THM->r_u32()); BT.THM.border_color = THM->r_u32(); BT.THM.fade_color = THM->r_u32(); BT.THM.fade_amount = THM->r_u32(); BT.THM.mip_filter = THM->r_u32(); BT.THM.width = THM->r_u32(); BT.THM.height = THM->r_u32(); BOOL bLOD=FALSE; if (N[0]=='l' && N[1]=='o' && N[2]=='d' && N[3]=='\\') bLOD = TRUE; // load surface if it has an alpha channel or has "implicit lighting" flag BT.dwWidth = BT.THM.width; BT.dwHeight = BT.THM.height; BT.bHasAlpha = BT.THM.HasAlphaChannel(); BT.pSurface = 0; if (!bLOD) { if (BT.bHasAlpha || BT.THM.flags.test(STextureParams::flImplicitLighted)) { clMsg ("- loading: %s",N); u32 w=0, h=0; BT.pSurface = Surface_Load(N,w,h); R_ASSERT2 (BT.pSurface,"Can't load surface"); if ((w != BT.dwWidth) || (h != BT.dwHeight)) Msg ("! THM doesn't correspond to the texture: %dx%d -> %dx%d", BT.dwWidth, BT.dwHeight, w, h); BT.Vflip (); } else { // Free surface memory } } } // save all the stuff we've created g_textures.push_back (BT); } } } }
void CKinematics::Load(const char* N, IReader *data, u32 dwFlags) { //Msg ("skeleton: %s",N); inherited::Load (N, data, dwFlags); pUserData = NULL; m_lod = NULL; // loading lods IReader* LD = data->open_chunk(OGF_S_LODS); if (LD) { string_path short_name; strcpy_s (short_name,sizeof(short_name),N); if (strext(short_name)) *strext(short_name)=0; // From stream { string_path lod_name; LD->r_string (lod_name, sizeof(lod_name)); //. strconcat (sizeof(name_load),name_load, short_name, ":lod:", lod_name.c_str()); m_lod = ::Render->model_CreateChild(lod_name, NULL); VERIFY3(m_lod,"Cant create LOD model for", N); //. VERIFY2 (m_lod->Type==MT_HIERRARHY || m_lod->Type==MT_PROGRESSIVE || m_lod->Type==MT_NORMAL,lod_name.c_str()); /* strconcat (name_load, short_name, ":lod:1"); m_lod = ::Render->model_CreateChild(name_load,LD); VERIFY (m_lod->Type==MT_SKELETON_GEOMDEF_PM || m_lod->Type==MT_SKELETON_GEOMDEF_ST); */ } LD->close (); } #ifndef _EDITOR // User data IReader* UD = data->open_chunk(OGF_S_USERDATA); pUserData = UD?xr_new<CInifile>(UD,FS.get_path("$game_config$")->m_Path):0; if (UD) UD->close(); #endif // Globals bone_map_N = xr_new<accel> (); bone_map_P = xr_new<accel> (); bones = xr_new<vecBones> (); bone_instances = NULL; // Load bones #pragma todo("container is created in stack!") xr_vector<shared_str> L_parents; R_ASSERT (data->find_chunk(OGF_S_BONE_NAMES)); visimask.zero (); int dwCount = data->r_u32(); // Msg ("!!! %d bones",dwCount); // if (dwCount >= 64) Msg ("!!! More than 64 bones is a crazy thing! (%d), %s",dwCount,N); VERIFY3 (dwCount < 64, "More than 64 bones is a crazy thing!",N); for (; dwCount; dwCount--) { string256 buf; // Bone u16 ID = u16(bones->size()); data->r_stringZ (buf,sizeof(buf)); strlwr(buf); CBoneData* pBone = CreateBoneData(ID); pBone->name = shared_str(buf); pBone->child_faces.resize (children.size()); bones->push_back (pBone); bone_map_N->push_back (mk_pair(pBone->name,ID)); bone_map_P->push_back (mk_pair(pBone->name,ID)); // It's parent data->r_stringZ (buf,sizeof(buf)); strlwr(buf); L_parents.push_back (buf); data->r (&pBone->obb,sizeof(Fobb)); visimask.set (u64(1)<<ID,TRUE); } std::sort (bone_map_N->begin(),bone_map_N->end(),pred_sort_N); std::sort (bone_map_P->begin(),bone_map_P->end(),pred_sort_P); // Attach bones to their parents iRoot = BI_NONE; for (u32 i=0; i<bones->size(); i++) { shared_str P = L_parents[i]; CBoneData* B = (*bones)[i]; if (!P||!P[0]) { // no parent - this is root bone R_ASSERT (BI_NONE==iRoot); iRoot = u16(i); B->SetParentID(BI_NONE); continue; } else { u16 ID = LL_BoneID(P); R_ASSERT (ID!=BI_NONE); (*bones)[ID]->children.push_back(B); B->SetParentID(ID); } } R_ASSERT (BI_NONE != iRoot); // Free parents L_parents.clear(); // IK data IReader* IKD = data->open_chunk(OGF_S_IKDATA); if (IKD){ for (u32 i=0; i<bones->size(); i++) { CBoneData* B = (*bones)[i]; u16 vers = (u16)IKD->r_u32(); IKD->r_stringZ (B->game_mtl_name); IKD->r (&B->shape,sizeof(SBoneShape)); B->IK_data.Import(*IKD,vers); Fvector vXYZ,vT; IKD->r_fvector3 (vXYZ); IKD->r_fvector3 (vT); B->bind_transform.setXYZi(vXYZ); B->bind_transform.translate_over(vT); B->mass = IKD->r_float(); IKD->r_fvector3 (B->center_of_mass); } // calculate model to bone converting matrix (*bones)[LL_GetBoneRoot()]->CalculateM2B(Fidentity); IKD->close(); } // after load process { for (u16 child_idx=0; child_idx<(u16)children.size(); child_idx++) LL_GetChild(child_idx)->AfterLoad (this,child_idx); } // unique bone faces { for (u32 bone_idx=0; bone_idx<bones->size(); bone_idx++) { CBoneData* B = (*bones)[bone_idx]; for (u32 child_idx=0; child_idx<children.size(); child_idx++){ CBoneData::FacesVec faces = B->child_faces[child_idx]; std::sort (faces.begin(),faces.end()); CBoneData::FacesVecIt new_end = std::unique(faces.begin(),faces.end()); faces.erase (new_end,faces.end()); B->child_faces[child_idx].clear_and_free(); B->child_faces[child_idx] = faces; } } } // reset update_callback Update_Callback = NULL; // reset update frame wm_frame = u32(-1); LL_Validate (); }
bool CEditableObject::Load(IReader& F) { bool bRes = true; do{ u32 version = 0; shared_str buf; shared_str sh_name; R_ASSERT(F.r_chunk(EOBJ_CHUNK_VERSION,&version)); if (version!=EOBJ_CURRENT_VERSION){ ELog.DlgMsg( mtError, "CEditableObject: unsupported file version. Object can't load."); bRes = false; break; } R_ASSERT(F.r_chunk(EOBJ_CHUNK_FLAGS, &m_Flags.flags)); if (F.find_chunk (EOBJ_CHUNK_CLASSSCRIPT)){ F.r_stringZ (m_ClassScript); } if (F.find_chunk (EOBJ_CHUNK_LODS)){ F.r_stringZ (m_LODs); } // surfaces if (F.find_chunk(EOBJ_CHUNK_SURFACES3)){ u32 cnt = F.r_u32(); m_Surfaces.resize(cnt); for (SurfaceIt s_it=m_Surfaces.begin(); s_it!=m_Surfaces.end(); s_it++){ *s_it = xr_new<CSurface>(); F.r_stringZ (buf); (*s_it)->SetName (buf.c_str()); F.r_stringZ (buf); (*s_it)->SetShader (buf.c_str()); F.r_stringZ (buf); (*s_it)->SetShaderXRLC (buf.c_str()); F.r_stringZ (buf); (*s_it)->SetGameMtl (buf.c_str()); F.r_stringZ (buf); (*s_it)->SetTexture (buf.c_str()); F.r_stringZ (buf); (*s_it)->SetVMap (buf.c_str()); (*s_it)->m_Flags.assign(F.r_u32()); (*s_it)->SetFVF (F.r_u32()); cnt = F.r_u32(); if (cnt>1) ELog.DlgMsg(mtError,"Object surface '%s' has more than one TC's.",buf.c_str()); R_ASSERT(1<=cnt); } }else if (F.find_chunk(EOBJ_CHUNK_SURFACES2)){ u32 cnt = F.r_u32(); m_Surfaces.resize(cnt); for (SurfaceIt s_it=m_Surfaces.begin(); s_it!=m_Surfaces.end(); s_it++){ *s_it = xr_new<CSurface>(); F.r_stringZ (buf); (*s_it)->SetName (buf.c_str()); F.r_stringZ (buf); (*s_it)->SetShader (buf.c_str()); F.r_stringZ (buf); (*s_it)->SetShaderXRLC (buf.c_str()); F.r_stringZ (buf); (*s_it)->SetTexture (buf.c_str()); F.r_stringZ (buf); (*s_it)->SetVMap (buf.c_str()); (*s_it)->m_Flags.assign(F.r_u32()); (*s_it)->SetFVF (F.r_u32()); cnt = F.r_u32(); if (cnt>1) ELog.DlgMsg(mtError,"Object surface '%s' has more than one TC's.",buf.c_str()); R_ASSERT(1<=cnt); } }else{ R_ASSERT(F.find_chunk(EOBJ_CHUNK_SURFACES)); u32 cnt = F.r_u32(); m_Surfaces.resize(cnt); for (SurfaceIt s_it=m_Surfaces.begin(); s_it!=m_Surfaces.end(); s_it++){ *s_it = xr_new<CSurface>(); F.r_stringZ(buf); (*s_it)->SetName(buf.c_str()); F.r_stringZ(sh_name); (*s_it)->m_Flags.set(CSurface::sf2Sided,!!F.r_u8()); (*s_it)->SetFVF (F.r_u32()); cnt = F.r_u32(); if (cnt>1) ELog.DlgMsg(mtError,"Object surface '%s' has more than one TC's.",buf.c_str()); R_ASSERT(1<=cnt); F.r_stringZ (buf); (*s_it)->SetTexture(buf.c_str()); F.r_stringZ (buf); (*s_it)->SetVMap(buf.c_str()); (*s_it)->SetShader (sh_name.c_str()); (*s_it)->SetShaderXRLC ("default"); } // surfaces xrlc part if(F.find_chunk(EOBJ_CHUNK_SURFACES_XRLC)) for (s_it=m_Surfaces.begin(); s_it!=m_Surfaces.end(); s_it++){ F.r_stringZ(buf); (*s_it)->SetShaderXRLC(buf.c_str()); } } // Load meshes IReader* OBJ = F.open_chunk(EOBJ_CHUNK_EDITMESHES); if(OBJ){ IReader* M = OBJ->open_chunk(0); for (int count=1; M; count++) { CEditableMesh* mesh=xr_new<CEditableMesh>(this); if (mesh->LoadMesh(*M)) m_Meshes.push_back(mesh); else{ ELog.DlgMsg( mtError, "CEditableObject: Can't load mesh '%s'!", *mesh->m_Name ); xr_delete(mesh); bRes = false; } M->close(); if (!bRes) break; M = OBJ->open_chunk(count); } OBJ->close(); } // bones if (bRes){ IReader* B_CHUNK = F.open_chunk(EOBJ_CHUNK_BONES2); if (B_CHUNK){ int chunk = 0; IReader* O; while (0!=(O=B_CHUNK->open_chunk(chunk++))){ m_Bones.push_back(xr_new<CBone>()); m_Bones.back()->Load_1(*O); O->close(); } B_CHUNK->close(); PrepareBones(); }else if (F.find_chunk(EOBJ_CHUNK_BONES)){ m_Bones.resize(F.r_u32()); for (BoneIt b_it=m_Bones.begin(); b_it!=m_Bones.end(); b_it++){ *b_it = xr_new<CBone>(); (*b_it)->Load_0(F); } PrepareBones(); } // skeleton motions if (F.find_chunk(EOBJ_CHUNK_SMOTIONS)){ m_SMotions.resize(F.r_u32()); for (SMotionIt s_it=m_SMotions.begin(); s_it!=m_SMotions.end(); s_it++){ *s_it = xr_new<CSMotion>(); if (!(*s_it)->Load(F)){ Log ("!Motions has different version. Load failed."); xr_delete(*s_it); m_SMotions.clear(); break; } // resort bone_mots (*s_it)->SortBonesBySkeleton(m_Bones); } } if (F.find_chunk(EOBJ_CHUNK_SMOTIONS2)){ F.r_stringZ (m_SMotionRefs); } } // bone parts if (bRes){ if (F.find_chunk(EOBJ_CHUNK_BONEPARTS)){ m_BoneParts.resize(F.r_u32()); bool bBPok = true; for (BPIt bp_it=m_BoneParts.begin(); bp_it!=m_BoneParts.end(); bp_it++){ F.r_stringZ (buf); bp_it->alias=buf; bp_it->bones.resize(F.r_u32()); for (RStringVecIt s_it=bp_it->bones.begin(); s_it!=bp_it->bones.end(); s_it++){ int idx = F.r_u32(); if ((idx>=0)&&(idx<(int)m_Bones.size())){ *s_it = m_Bones[idx]->Name(); }else{ Log ("!Invalid bone parts.",GetName()); bBPok = false; break; } } if (!bBPok) break; } if (!bBPok) m_BoneParts.clear(); if (!m_BoneParts.empty()&&!VerifyBoneParts()) Log ("!Invalid bone parts. Found duplicate bones in object '%s'.",GetName()); }else if (F.find_chunk(EOBJ_CHUNK_BONEPARTS2)){ m_BoneParts.resize(F.r_u32()); for (BPIt bp_it=m_BoneParts.begin(); bp_it!=m_BoneParts.end(); bp_it++){ F.r_stringZ (buf); bp_it->alias=buf; bp_it->bones.resize(F.r_u32()); for (RStringVecIt s_it=bp_it->bones.begin(); s_it!=bp_it->bones.end(); s_it++) F.r_stringZ(*s_it); } if (!m_BoneParts.empty()&&!VerifyBoneParts()) Log ("!Invalid bone parts. Found duplicate bones in object '%s'.",GetName()); } } if (bRes){ if (F.find_chunk (EOBJ_CHUNK_ACTORTRANSFORM)){ F.r_fvector3 (a_vPosition); F.r_fvector3 (a_vRotate); } if (F.find_chunk (EOBJ_CHUNK_DESC)){ F.r_stringZ (m_CreateName); F.r (&m_CreateTime,sizeof(m_CreateTime)); F.r_stringZ (m_ModifName); F.r (&m_ModifTime,sizeof(m_ModifTime)); } ResetSAnimation(); } if (!bRes) break; UpdateBox (); VerifyMeshNames (); }while(0); return bRes; }
CLevelGameGraph ( LPCSTR graph_file_name, LPCSTR raw_cross_table_file_name, CGameGraph::SLevel *tLevel, LPCSTR S, u32 dwOffset, u32 dwLevelID, CInifile *Ini ) { m_tLevel = *tLevel; m_dwOffset = dwOffset; m_tpLevelPoints.clear (); FILE_NAME caFileName; // loading graph strcpy_s (caFileName,graph_file_name); m_tpGraph = new CGameGraph(caFileName); strcpy_s (caFileName,raw_cross_table_file_name); CGameLevelCrossTable *l_tpCrossTable = new CGameLevelCrossTable(caFileName); CLevelGraph *l_tpAI_Map = new CLevelGraph(S); VERIFY2 (l_tpCrossTable->header().level_guid() == l_tpAI_Map->header().guid(), "cross table doesn't correspond to the AI-map, rebuild graph!"); VERIFY2 (l_tpCrossTable->header().game_guid() == m_tpGraph->header().guid(), "cross table doesn't correspond to the graph, rebuild graph!"); VERIFY2 (m_tpGraph->header().level(GameGraph::_LEVEL_ID(0)).guid() == l_tpAI_Map->header().guid(), "cross table doesn't correspond to the AI-map, rebuild graph!"); VERIFY (l_tpAI_Map->header().vertex_count() == l_tpCrossTable->header().level_vertex_count()); VERIFY (m_tpGraph->header().vertex_count() == l_tpCrossTable->header().game_vertex_count()); tLevel->m_guid = l_tpAI_Map->header().guid(); { for (GameGraph::_GRAPH_ID i=0, n = m_tpGraph->header().vertex_count(); i<n; ++i) if ((!l_tpAI_Map->valid_vertex_id(m_tpGraph->vertex(i)->level_vertex_id()) || (l_tpCrossTable->vertex(m_tpGraph->vertex(i)->level_vertex_id()).game_vertex_id() != i) || !l_tpAI_Map->inside(m_tpGraph->vertex(i)->level_vertex_id(),m_tpGraph->vertex(i)->level_point()))) { Msg ("! Graph doesn't correspond to the cross table"); R_ASSERT2 (false,"Graph doesn't correspond to the cross table"); } } m_tpVertices.resize (m_tpGraph->header().vertex_count()); GRAPH_VERTEX_IT B = m_tpVertices.begin(); GRAPH_VERTEX_IT I = B; GRAPH_VERTEX_IT E = m_tpVertices.end(); for ( ; I != E; I++) { (*I).tLocalPoint = m_tpGraph->vertex(int(I - B))->level_point(); (*I).tGlobalPoint.add (m_tpGraph->vertex(int(I - B))->game_point(),m_tLevel.offset()); (*I).tLevelID = dwLevelID; (*I).tNodeID = m_tpGraph->vertex(int(I - B))->level_vertex_id(); Memory.mem_copy ((*I).tVertexTypes,m_tpGraph->vertex(int(I - B))->vertex_type(),GameGraph::LOCATION_TYPE_COUNT*sizeof(GameGraph::_LOCATION_ID)); (*I).tNeighbourCount = m_tpGraph->vertex(int(I - B))->edge_count(); CGameGraph::const_iterator b,i,e; m_tpGraph->begin (int(I - B),i,e); (*I).tpaEdges = (CGameGraph::CEdge*)xr_malloc((*I).tNeighbourCount*sizeof(CGameGraph::CEdge)); b = i; for ( ; i != e; ++i) { GameGraph::CEdge &edge = (*I).tpaEdges[i - b]; edge = *i; VERIFY ((edge.vertex_id() + dwOffset) < (u32(1) << (8*sizeof(GameGraph::_GRAPH_ID)))); edge.m_vertex_id = (GameGraph::_GRAPH_ID)(edge.m_vertex_id + dwOffset); } (*I).dwPointOffset = 0; vfGenerateDeathPoints (int(I - B),l_tpCrossTable,l_tpAI_Map,(*I).tDeathPointCount); } xr_delete (l_tpCrossTable); xr_delete (l_tpAI_Map); // updating cross-table { strcpy_s (caFileName,raw_cross_table_file_name); CGameLevelCrossTable *tpCrossTable = new CGameLevelCrossTable(caFileName); xr_vector<CGameLevelCrossTable::CCell> tCrossTableUpdate; tCrossTableUpdate.resize(tpCrossTable->header().level_vertex_count()); for (int i=0; i<(int)tpCrossTable->header().level_vertex_count(); i++) { tCrossTableUpdate[i] = tpCrossTable->vertex(i); VERIFY (u32(tCrossTableUpdate[i].tGraphIndex) < tpCrossTable->header().game_vertex_count()); tCrossTableUpdate[i].tGraphIndex = tCrossTableUpdate[i].tGraphIndex + (GameGraph::_GRAPH_ID)dwOffset; } CGameLevelCrossTable::CHeader tCrossTableHeader; tCrossTableHeader.dwVersion = XRAI_CURRENT_VERSION; tCrossTableHeader.dwNodeCount = tpCrossTable->m_tCrossTableHeader.dwNodeCount; tCrossTableHeader.dwGraphPointCount = tpCrossTable->m_tCrossTableHeader.dwGraphPointCount; tCrossTableHeader.m_level_guid = tpCrossTable->m_tCrossTableHeader.m_level_guid; tCrossTableHeader.m_game_guid = tGraphHeader.m_guid; xr_delete (tpCrossTable); m_cross_table.w(&tCrossTableHeader,sizeof(tCrossTableHeader)); for (int i=0; i<(int)tCrossTableHeader.dwNodeCount; i++) m_cross_table.w(&(tCrossTableUpdate[i]),sizeof(tCrossTableUpdate[i])); } // fill vertex map { string_path fName; strconcat (sizeof(fName),fName,S,"level.spawn"); IReader *F = FS.r_open(fName); u32 id; IReader *O = F->open_chunk_iterator(id); for (int i=0; O; O = F->open_chunk_iterator(id,O)) { NET_Packet P; P.B.count = O->length(); O->r (P.B.data,P.B.count); u16 ID; P.r_begin (ID); R_ASSERT (M_SPAWN==ID); P.r_stringZ (fName); CSE_Abstract *E = F_entity_Create(fName); R_ASSERT3 (E,"Can't create entity.",fName); // E->Spawn_Read (P); CSE_ALifeGraphPoint *tpGraphPoint = smart_cast<CSE_ALifeGraphPoint*>(E); if (tpGraphPoint) { E->Spawn_Read (P); Fvector tVector; tVector = tpGraphPoint->o_Position; GameGraph::_GRAPH_ID tGraphID = GameGraph::_GRAPH_ID(-1); float fMinDistance = 1000000.f; { GRAPH_VERTEX_IT B = m_tpVertices.begin(); GRAPH_VERTEX_IT I = B; GRAPH_VERTEX_IT E = m_tpVertices.end(); for ( ; I != E; I++) { float fDistance = (*I).tLocalPoint.distance_to(tVector); if (fDistance < fMinDistance) { fMinDistance = fDistance; tGraphID = GameGraph::_GRAPH_ID(I - B); if (fMinDistance < EPS_L) break; } } } if (fMinDistance < EPS_L) { SConnectionVertex T; LPSTR S; S = xr_strdup(tpGraphPoint->name_replace()); T.caConnectName = xr_strdup(*tpGraphPoint->m_caConnectionPointName); T.dwLevelID = dwfGetIDByLevelName(Ini,*tpGraphPoint->m_caConnectionLevelName); // T.tGraphID = (GameGraph::_GRAPH_ID)i; // T.tOldGraphID = tGraphID; T.tOldGraphID = (GameGraph::_GRAPH_ID)i; T.tGraphID = tGraphID; bool ok = true; VERTEX_MAP::const_iterator II = m_tVertexMap.begin(); VERTEX_MAP::const_iterator EE = m_tVertexMap.end(); for ( ; II != EE; ++II) if (T.tOldGraphID == (*II).second.tOldGraphID) { ok = false; Msg ("Graph point %s is removed,because it has the same position as some another graph point",E->name_replace()); break; } if (ok) { m_tVertexMap.insert (mk_pair(S,T)); i++; } } } F_entity_Destroy (E); } if (i != m_tpGraph->header().vertex_count()) Msg ("Graph for the level %s doesn't correspond to the graph points from Level Editor! (%d : %d)",*m_tLevel.name(),i,m_tpGraph->header().vertex_count()); VERTEX_MAP::const_iterator I = m_tVertexMap.begin(); VERTEX_MAP::const_iterator E = m_tVertexMap.end(); for ( ; I != E; ++I) { R_ASSERT3 (!xr_strlen((*I).second.caConnectName) || ((*I).second.tGraphID < m_tpVertices.size()),"Rebuild graph for the level",*m_tLevel.name()); } // VERIFY3 (i == m_tpGraph->header().vertex_count(), "Rebuild graph for the level ",m_tLevel.name()); O->close (); FS.r_close (F); } };
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; }
//----------------------------------------------------------------------- BOOL motions_value::load (LPCSTR N, IReader *data, vecBones* bones) { m_id = N; bool bRes = true; // Load definitions U16Vec rm_bones (bones->size(),BI_NONE); IReader* MP = data->open_chunk(OGF_S_SMPARAMS); if (MP) { u16 vers = MP->r_u16(); u16 part_bone_cnt = 0; string128 buf; R_ASSERT3 (vers<=xrOGF_SMParamsVersion,"Invalid OGF/OMF version:",N); // partitions u16 part_count; part_count = MP->r_u16(); for (u16 part_i=0; part_i<part_count; part_i++) { CPartDef& PART = m_partition[part_i]; MP->r_stringZ (buf,sizeof(buf)); PART.Name = _strlwr(buf); PART.bones.resize (MP->r_u16()); for (xr_vector<u32>::iterator b_it=PART.bones.begin(); b_it<PART.bones.end(); b_it++) { MP->r_stringZ (buf,sizeof(buf)); u16 m_idx = u16 (MP->r_u32()); *b_it = find_bone_id (bones,buf); #ifdef _EDITOR if (*b_it==BI_NONE ) { bRes = false; Msg ("! Can't find bone: '%s'", buf); } if (rm_bones.size() <= m_idx) { bRes = false; Msg ("! Can't load: '%s' invalid bones count", N); } #else VERIFY3 (*b_it!=BI_NONE,"Can't find bone:", buf); #endif if (bRes) rm_bones[m_idx] = u16(*b_it); } part_bone_cnt = u16(part_bone_cnt + (u16)PART.bones.size()); } #ifdef _EDITOR if (part_bone_cnt!=(u16)bones->size()){ bRes = false; Msg("! Different bone count[%s] [Object: '%d' <-> Motions: '%d']", N, bones->size(),part_bone_cnt); } #else VERIFY3(part_bone_cnt==(u16)bones->size(),"Different bone count '%s'",N); #endif if (bRes) { // motion defs (cycle&fx) u16 mot_count = MP->r_u16(); m_mdefs.resize (mot_count); for (u16 mot_i=0; mot_i<mot_count; mot_i++) { MP->r_stringZ (buf,sizeof(buf)); shared_str nm = _strlwr (buf); u32 dwFlags = MP->r_u32 (); CMotionDef& D = m_mdefs[mot_i]; D.Load (MP,dwFlags,vers); //. m_mdefs.push_back (D); if (dwFlags&esmFX) m_fx.insert (mk_pair(nm,mot_i)); else m_cycle.insert (mk_pair(nm,mot_i)); m_motion_map.insert (mk_pair(nm,mot_i)); } } MP->close(); }else { xrDebug::Fatal (DEBUG_INFO,"Old skinned model version unsupported! (%s)",N); } if (!bRes) return false; // Load animation IReader* MS = data->open_chunk(OGF_S_MOTIONS); if (!MS) return false; u32 dwCNT = 0; MS->r_chunk_safe (0,&dwCNT,sizeof(dwCNT)); VERIFY (dwCNT<0x3FFF); // MotionID 2 bit - slot, 14 bit - motion index // set per bone motion size for (u32 i=0; i<bones->size(); i++) m_motions[bones->at(i)->name].resize(dwCNT); // load motions for (u16 m_idx=0; m_idx<(u16)dwCNT; m_idx++){ string128 mname; R_ASSERT (MS->find_chunk(m_idx+1)); MS->r_stringZ (mname,sizeof(mname)); #ifdef _DEBUG // sanity check xr_strlwr (mname); accel_map::iterator I= m_motion_map.find(mname); VERIFY3 (I!=m_motion_map.end(),"Can't find motion:",mname); VERIFY3 (I->second==m_idx,"Invalid motion index:",mname); #endif u32 dwLen = MS->r_u32(); for (u32 i=0; i<bones->size(); i++){ u16 bone_id = rm_bones[i]; VERIFY2 (bone_id!=BI_NONE,"Invalid remap index."); CMotion& M = m_motions[bones->at(bone_id)->name][m_idx]; M.set_count (dwLen); M.set_flags (MS->r_u8()); if (M.test_flag(flRKeyAbsent)) { CKeyQR* r = (CKeyQR*)MS->pointer(); u32 crc_q = crc32(r,sizeof(CKeyQR)); M._keysR.create (crc_q,1,r); MS->advance (1 * sizeof(CKeyQR)); }else{ u32 crc_q = MS->r_u32 (); M._keysR.create (crc_q,dwLen,(CKeyQR*)MS->pointer()); MS->advance (dwLen * sizeof(CKeyQR)); } if (M.test_flag(flTKeyPresent)) { u32 crc_t = MS->r_u32 (); if(M.test_flag(flTKey16IsBit)) { M._keysT16.create (crc_t,dwLen,(CKeyQT16*)MS->pointer()); MS->advance (dwLen * sizeof(CKeyQT16)); }else { M._keysT8.create (crc_t,dwLen,(CKeyQT8*)MS->pointer()); MS->advance (dwLen * sizeof(CKeyQT8)); }; MS->r_fvector3 (M._sizeT); MS->r_fvector3 (M._initT); }else { MS->r_fvector3 (M._initT); } } } // Msg("Motions %d/%d %4d/%4d/%d, %s",p_cnt,m_cnt, m_load,m_total,m_r,N); MS->close(); return bRes; }
void CRender::level_Load(IReader* fs) { R_ASSERT (0!=g_pGameLevel); R_ASSERT (!b_loaded); // Begin pApp->LoadBegin (); dxRenderDeviceRender::Instance().Resources->DeferredLoad (TRUE); IReader* chunk; // Shaders // g_pGamePersistent->LoadTitle ("st_loading_shaders"); g_pGamePersistent->LoadTitle (); { chunk = fs->open_chunk (fsL_SHADERS); R_ASSERT2 (chunk,"Level doesn't builded correctly."); u32 count = chunk->r_u32 (); Shaders.resize (count); for(u32 i=0; i<count; i++) // skip first shader as "reserved" one { string512 n_sh,n_tlist; LPCSTR n = LPCSTR(chunk->pointer()); chunk->skip_stringZ (); if (0==n[0]) continue; xr_strcpy (n_sh,n); LPSTR delim = strchr(n_sh,'/'); *delim = 0; xr_strcpy (n_tlist,delim+1); Shaders[i] = dxRenderDeviceRender::Instance().Resources->Create(n_sh,n_tlist); } chunk->close(); } // Components Wallmarks = xr_new<CWallmarksEngine> (); Details = xr_new<CDetailManager> (); if (!g_dedicated_server) { // VB,IB,SWI // g_pGamePersistent->LoadTitle("st_loading_geometry"); g_pGamePersistent->LoadTitle(); { CStreamReader *geom = FS.rs_open("$level$","level.geom"); R_ASSERT2 (geom, "level.geom"); LoadBuffers (geom,FALSE); LoadSWIs (geom); FS.r_close (geom); } //...and alternate/fast geometry { CStreamReader *geom = FS.rs_open("$level$","level.geomx"); R_ASSERT2 (geom, "level.geomX"); LoadBuffers (geom,TRUE); FS.r_close (geom); } // Visuals // g_pGamePersistent->LoadTitle("st_loading_spatial_db"); g_pGamePersistent->LoadTitle(); chunk = fs->open_chunk(fsL_VISUALS); LoadVisuals (chunk); chunk->close (); // Details // g_pGamePersistent->LoadTitle("st_loading_details"); g_pGamePersistent->LoadTitle(); Details->Load (); } // Sectors // g_pGamePersistent->LoadTitle("st_loading_sectors_portals"); g_pGamePersistent->LoadTitle(); LoadSectors (fs); // 3D Fluid Load3DFluid (); // HOM HOM.Load (); // Lights // pApp->LoadTitle ("Loading lights..."); LoadLights (fs); // End pApp->LoadEnd (); // sanity-clear lstLODs.clear (); lstLODgroups.clear (); mapLOD.clear (); // signal loaded b_loaded = TRUE ; }
void CGameMtlLibrary::Load() { string_path name; if (!FS.exist(name, _game_data_,GAMEMTL_FILENAME)){ Log ("! Can't find game material file: ",name); return; } R_ASSERT (material_pairs.empty()); R_ASSERT (materials.empty()); destructor<IReader> F(FS.r_open(name)); IReader& fs = F(); R_ASSERT(fs.find_chunk(GAMEMTLS_CHUNK_VERSION)); u16 version = fs.r_u16(); if (GAMEMTL_CURRENT_VERSION!=version){ Log ("CGameMtlLibrary: invalid version. Library can't load."); return; } R_ASSERT(fs.find_chunk(GAMEMTLS_CHUNK_AUTOINC)); material_index = fs.r_u32(); material_pair_index = fs.r_u32(); materials.clear (); material_pairs.clear(); IReader* OBJ = fs.open_chunk(GAMEMTLS_CHUNK_MTLS); if (OBJ) { u32 count; for (IReader* O = OBJ->open_chunk_iterator(count); O; O = OBJ->open_chunk_iterator(count,O)) { SGameMtl* M = new SGameMtl(); M->Load (*O); materials.push_back(M); } OBJ->close (); } OBJ = fs.open_chunk(GAMEMTLS_CHUNK_MTLS_PAIR); if (OBJ){ u32 count; for (IReader* O = OBJ->open_chunk_iterator(count); O; O = OBJ->open_chunk_iterator(count,O)) { SGameMtlPair* M = new SGameMtlPair(this); M->Load (*O); material_pairs.push_back(M); } OBJ->close (); } #ifndef _EDITOR material_count = (u32)materials.size(); material_pairs_rt.resize(material_count*material_count,0); for (GameMtlPairIt p_it=material_pairs.begin(); material_pairs.end() != p_it; ++p_it){ SGameMtlPair* S = *p_it; int idx0 = GetMaterialIdx(S->mtl0)*material_count+GetMaterialIdx(S->mtl1); int idx1 = GetMaterialIdx(S->mtl1)*material_count+GetMaterialIdx(S->mtl0); material_pairs_rt[idx0]=S; material_pairs_rt[idx1]=S; } #endif /* for (GameMtlPairIt p_it=material_pairs.begin(); material_pairs.end() != p_it; ++p_it){ SGameMtlPair* S = *p_it; for (int k=0; k<S->StepSounds.size(); k++){ Msg("%40s - 0x%x", S->StepSounds[k].handle->file_name(), S->StepSounds[k].g_type); } } */ }
void CRender::LoadSectors(IReader* fs) { // allocate memory for portals u32 size = fs->find_chunk(fsL_PORTALS); R_ASSERT(0==size%sizeof(b_portal)); u32 count = size/sizeof(b_portal); Portals.resize (count); for (u32 c=0; c<count; c++) Portals[c] = xr_new<CPortal> (); // load sectors IReader* S = fs->open_chunk(fsL_SECTORS); for (u32 i=0; ; i++) { IReader* P = S->open_chunk(i); if (0==P) break; CSector* __S = xr_new<CSector> (); __S->load (*P); Sectors.push_back (__S); P->close(); } S->close(); // load portals if (count) { CDB::Collector CL; fs->find_chunk (fsL_PORTALS); for (i=0; i<count; i++) { b_portal P; fs->r (&P,sizeof(P)); CPortal* __P = (CPortal*)Portals[i]; __P->Setup (P.vertices.begin(),P.vertices.size(), (CSector*)getSector(P.sector_front), (CSector*)getSector(P.sector_back)); for (u32 j=2; j<P.vertices.size(); j++) CL.add_face_packed_D( P.vertices[0],P.vertices[j-1],P.vertices[j], u32(i) ); } if (CL.getTS()<2) { Fvector v1,v2,v3; v1.set (-20000.f,-20000.f,-20000.f); v2.set (-20001.f,-20001.f,-20001.f); v3.set (-20002.f,-20002.f,-20002.f); CL.add_face_packed_D (v1,v2,v3,0); } // build portal model rmPortals = xr_new<CDB::MODEL> (); rmPortals->build (CL.getV(),int(CL.getVS()),CL.getT(),int(CL.getTS())); } else { rmPortals = 0; } // debug // for (int d=0; d<Sectors.size(); d++) // Sectors[d]->DebugDump (); pLastSector = 0; }
void xrLoad(LPCSTR name, bool draft_mode) { FS.get_path ("$level$")->_set ((LPSTR)name); string256 N; if (!draft_mode) { // shaders string_path N; FS.update_path (N,"$game_data$","shaders_xrlc.xr"); g_shaders_xrlc = xr_new<Shader_xrLC_LIB> (); g_shaders_xrlc->Load (N); // Load CFORM { strconcat (sizeof(N),N,name,"build.cform"); IReader* fs = FS.r_open(N); R_ASSERT (fs->find_chunk(0)); hdrCFORM H; fs->r (&H,sizeof(hdrCFORM)); R_ASSERT (CFORM_CURRENT_VERSION==H.version); Fvector* verts = (Fvector*)fs->pointer(); CDB::TRI* tris = (CDB::TRI*)(verts+H.vertcount); Level.build ( verts, H.vertcount, tris, H.facecount ); Level.syncronize (); Msg("* Level CFORM: %dK",Level.memory()/1024); g_rc_faces.resize (H.facecount); R_ASSERT(fs->find_chunk(1)); fs->r (&*g_rc_faces.begin(),g_rc_faces.size()*sizeof(b_rc_face)); LevelBB.set (H.aabb); FS.r_close (fs); } // Load level data { strconcat (sizeof(N),N,name,"build.prj"); IReader* fs = FS.r_open (N); IReader* F; // Version u32 version; fs->r_chunk (EB_Version,&version); R_ASSERT (XRCL_CURRENT_VERSION >= 17); R_ASSERT (XRCL_CURRENT_VERSION <= 18); // Header b_params Params; fs->r_chunk (EB_Parameters,&Params); // Load level data transfer("materials", g_materials, *fs, EB_Materials); transfer("shaders_xrlc",g_shader_compile, *fs, EB_Shaders_Compile); // process textures Status ("Processing textures..."); { Surface_Init (); F = fs->open_chunk (EB_Textures); u32 tex_count = F->length()/sizeof(b_texture); for (u32 t=0; t<tex_count; t++) { Progress (float(t)/float(tex_count)); b_texture TEX; F->r (&TEX,sizeof(TEX)); b_BuildTexture BT; CopyMemory (&BT,&TEX,sizeof(TEX)); // load thumbnail string128 &N = BT.name; LPSTR extension = strext(N); if (extension) *extension = 0; xr_strlwr (N); if (0==xr_strcmp(N,"level_lods")) { // HACK for merged lod textures BT.dwWidth = 1024; BT.dwHeight = 1024; BT.bHasAlpha= TRUE; BT.pSurface = 0; } else { xr_strcat (N,".thm"); IReader* THM = FS.r_open("$game_textures$",N); // if (!THM) continue; R_ASSERT2 (THM, N); // version u32 version = 0; R_ASSERT (THM->r_chunk(THM_CHUNK_VERSION,&version)); // if( version!=THM_CURRENT_VERSION ) FATAL ("Unsupported version of THM file."); // analyze thumbnail information R_ASSERT(THM->find_chunk(THM_CHUNK_TEXTUREPARAM)); THM->r (&BT.THM.fmt,sizeof(STextureParams::ETFormat)); BT.THM.flags.assign (THM->r_u32()); BT.THM.border_color = THM->r_u32(); BT.THM.fade_color = THM->r_u32(); BT.THM.fade_amount = THM->r_u32(); BT.THM.mip_filter = THM->r_u32(); BT.THM.width = THM->r_u32(); BT.THM.height = THM->r_u32(); BOOL bLOD=FALSE; if (N[0]=='l' && N[1]=='o' && N[2]=='d' && N[3]=='\\') bLOD = TRUE; // load surface if it has an alpha channel or has "implicit lighting" flag BT.dwWidth = BT.THM.width; BT.dwHeight = BT.THM.height; BT.bHasAlpha = BT.THM.HasAlphaChannel(); BT.pSurface = 0; if (!bLOD) { if (BT.bHasAlpha || BT.THM.flags.test(STextureParams::flImplicitLighted)) { clMsg ("- loading: %s",N); u32 w=0, h=0; BT.pSurface = Surface_Load(N,w,h); R_ASSERT2 (BT.pSurface,"Can't load surface"); if ((w != BT.dwWidth) || (h != BT.dwHeight)) Msg ("! THM doesn't correspond to the texture: %dx%d -> %dx%d", BT.dwWidth, BT.dwHeight, w, h); BT.Vflip (); } else { // Free surface memory } } } // save all the stuff we've created g_textures.push_back (BT); } } } } // // Load emitters // { // strconcat (N,name,"level.game"); // IReader *F = FS.r_open(N); // IReader *O = 0; // if (0!=(O = F->open_chunk (AIPOINT_CHUNK))) { // for (int id=0; O->find_chunk(id); id++) { // Emitters.push_back(Fvector()); // O->r_fvector3 (Emitters.back()); // } // O->close(); // } // } // // Load lights { strconcat (sizeof(N),N,name,"build.prj"); IReader* F = FS.r_open(N); R_ASSERT2 (F,"There is no file 'build.prj'!"); IReader &fs= *F; // Version u32 version; fs.r_chunk (EB_Version,&version); R_ASSERT (XRCL_CURRENT_VERSION >= 17); R_ASSERT (XRCL_CURRENT_VERSION <= 18); // Header b_params Params; fs.r_chunk (EB_Parameters,&Params); // Lights (Static) { F = fs.open_chunk(EB_Light_static); b_light_static temp; u32 cnt = F->length()/sizeof(temp); for (u32 i=0; i<cnt; i++) { R_Light RL; F->r (&temp,sizeof(temp)); Flight& L = temp.data; if (_abs(L.range) > 10000.f) { Msg ("! BAD light range : %f",L.range); L.range = L.range > 0.f ? 10000.f : -10000.f; } // type if (L.type == D3DLIGHT_DIRECTIONAL) RL.type = LT_DIRECT; else RL.type = LT_POINT; // generic properties RL.position.set (L.position); RL.direction.normalize_safe (L.direction); RL.range = L.range*1.1f; RL.range2 = RL.range*RL.range; RL.attenuation0 = L.attenuation0; RL.attenuation1 = L.attenuation1; RL.attenuation2 = L.attenuation2; RL.amount = L.diffuse.magnitude_rgb (); RL.tri[0].set (0,0,0); RL.tri[1].set (0,0,0); RL.tri[2].set (0,0,0); // place into layer if (0==temp.controller_ID) g_lights.push_back (RL); } F->close (); } } // Init params // g_params.Init (); // Load initial map from the Level Editor { string_path file_name; strconcat (sizeof(file_name),file_name,name,"build.aimap"); IReader *F = FS.r_open(file_name); R_ASSERT2 (F, file_name); R_ASSERT (F->open_chunk(E_AIMAP_CHUNK_VERSION)); R_ASSERT (F->r_u16() == E_AIMAP_VERSION); R_ASSERT (F->open_chunk(E_AIMAP_CHUNK_BOX)); F->r (&LevelBB,sizeof(LevelBB)); R_ASSERT (F->open_chunk(E_AIMAP_CHUNK_PARAMS)); F->r (&g_params,sizeof(g_params)); R_ASSERT (F->open_chunk(E_AIMAP_CHUNK_NODES)); u32 N = F->r_u32(); R_ASSERT2 (N < ((u32(1) << u32(MAX_NODE_BIT_COUNT)) - 2),"Too many nodes!"); g_nodes.resize (N); hdrNODES H; H.version = XRAI_CURRENT_VERSION; H.count = N+1; H.size = g_params.fPatchSize; H.size_y = 1.f; H.aabb = LevelBB; typedef BYTE NodeLink[3]; for (u32 i=0; i<N; i++) { NodeLink id; u16 pl; SNodePositionOld _np; NodePosition np; for (int j=0; j<4; ++j) { F->r (&id,3); g_nodes[i].n[j] = (*LPDWORD(&id)) & 0x00ffffff; } pl = F->r_u16(); pvDecompress (g_nodes[i].Plane.n,pl); F->r (&_np,sizeof(_np)); CNodePositionConverter(_np,H,np); g_nodes[i].Pos = vertex_position(np,LevelBB,g_params); g_nodes[i].Plane.build(g_nodes[i].Pos,g_nodes[i].Plane.n); } F->close (); if (!strstr(Core.Params,"-keep_temp_files")) DeleteFile (file_name); } }