void CBone::LoadData(IReader& F)
{
R_ASSERT(F.find_chunk(BONE_CHUNK_DEF));
F.r_stringZ (name); xr_strlwr(name);
R_ASSERT(F.find_chunk(BONE_CHUNK_MATERIAL));
F.r_stringZ (game_mtl);
R_ASSERT(F.find_chunk(BONE_CHUNK_SHAPE));
F.r (&shape,sizeof(SBoneShape));
if (F.find_chunk(BONE_CHUNK_FLAGS))
IK_data.ik_flags.assign(F.r_u32());
R_ASSERT(F.find_chunk(BONE_CHUNK_IK_JOINT));
IK_data.type = (EJointType)F.r_u32();
F.r (IK_data.limits,sizeof(SJointLimit)*3);
IK_data.spring_factor = F.r_float();
IK_data.damping_factor = F.r_float();
if (F.find_chunk(BONE_CHUNK_IK_JOINT_BREAK)){
IK_data.break_force = F.r_float();
IK_data.break_torque= F.r_float();
}
if (F.find_chunk(BONE_CHUNK_IK_JOINT_FRICTION)){
IK_data.friction = F.r_float();
}
if (F.find_chunk(BONE_CHUNK_MASS)){
mass = F.r_float();
F.r_fvector3(center_of_mass);
}
}
bool CGroupObject::Load(IReader& F)
{
u32 version = 0;
char buf[1024];
R_ASSERT(F.r_chunk(GROUPOBJ_CHUNK_VERSION,&version));
if (version!=GROUPOBJ_CURRENT_VERSION){
ELog.DlgMsg( mtError, "CGroupObject: unsupported file version. Object can't load.");
return false;
}
CCustomObject::Load(F);
F.r_chunk(GROUPOBJ_CHUNK_FLAGS,&m_Flags);
// objects
if (IsOpened()){
m_PObjects = xr_new<SStringVec>();
R_ASSERT(F.find_chunk(GROUPOBJ_CHUNK_OPEN_OBJECT_LIST));
u32 cnt = F.r_u32();
xr_string tmp;
for (u32 k=0; k<cnt; k++){
F.r_stringZ (tmp);
m_PObjects->push_back (tmp);
}
}else{
Scene->ReadObjects(F,GROUPOBJ_CHUNK_OBJECT_LIST,AppendObjectCB,0);
}
VERIFY(m_Objects.size()||(0!=m_PObjects));
if (F.find_chunk(GROUPOBJ_CHUNK_REFERENCE))
F.r_stringZ (m_ReferenceName);
return true;
}
bool CGlow::Load(IReader& F)
{
u32 version = 0;
R_ASSERT(F.r_chunk(GLOW_CHUNK_VERSION,&version));
if((version!=0x0011)&&(version!=GLOW_VERSION)){
ELog.DlgMsg( mtError, "CGlow: Unsupported version.");
return false;
}
CCustomObject::Load(F);
if (F.find_chunk(GLOW_CHUNK_SHADER)){
F.r_stringZ (m_ShaderName);
}
R_ASSERT(F.find_chunk(GLOW_CHUNK_TEXTURE));
F.r_stringZ (m_TexName);
R_ASSERT(F.find_chunk(GLOW_CHUNK_PARAMS));
m_fRadius = F.r_float();
if (version==0x0011){
F.r_fvector3 (FPosition);
UpdateTransform();
}
if (F.find_chunk(GLOW_CHUNK_FLAGS))
m_Flags.assign (F.r_u16());
return true;
}
void SGameMtl::Load(IReader& fs)
{
R_ASSERT(fs.find_chunk(GAMEMTL_CHUNK_MAIN));
ID = fs.r_u32();
fs.r_stringZ (m_Name);
if (fs.find_chunk(GAMEMTL_CHUNK_DESC)){
fs.r_stringZ (m_Desc);
}
R_ASSERT(fs.find_chunk(GAMEMTL_CHUNK_FLAGS));
Flags.assign (fs.r_u32());
R_ASSERT(fs.find_chunk(GAMEMTL_CHUNK_PHYSICS));
fPHFriction = fs.r_float();
fPHDamping = fs.r_float();
fPHSpring = fs.r_float();
fPHBounceStartVelocity = fs.r_float();
fPHBouncing = fs.r_float();
R_ASSERT(fs.find_chunk(GAMEMTL_CHUNK_FACTORS));
fShootFactor = fs.r_float();
fBounceDamageFactor = fs.r_float();
fVisTransparencyFactor = fs.r_float();
fSndOcclusionFactor = fs.r_float();
if(fs.find_chunk(GAMEMTL_CHUNK_FLOTATION))
fFlotationFactor = fs.r_float();
if(fs.find_chunk(GAMEMTL_CHUNK_INJURIOUS))
fInjuriousSpeed = fs.r_float();
}
void CMapLocation::load(IReader &stream)
{
xr_string str;
stream.r_stringZ(str);
SetHint (str.c_str());
m_flags.flags = stream.r_u32 ();
stream.r_stringZ(str);
m_owner_task_id = str.c_str();
}
void CBone::Load_0(IReader& F)
{
F.r_stringZ (name); xr_strlwr(name);
F.r_stringZ (parent_name); xr_strlwr(parent_name);
F.r_stringZ (wmap);
F.r_fvector3 (rest_offset);
F.r_fvector3 (rest_rotate);
rest_length = F.r_float();
std::swap (rest_rotate.x,rest_rotate.y);
Reset ();
}
bool CEditableObject::LoadBoneData(IReader& F)
{
BoneVec load_bones;
int count=0;
IReader* R;
while(0!=(R=F.open_chunk(count++)))
{
CBone* nBone = xr_new<CBone>();
load_bones.push_back(nBone);
nBone->LoadData(*R);
Msg("loaded bone [%s]", nBone->Name().c_str());
}
bool bRes = true;
// load bones
if (!load_bones.empty()){
for (BoneIt b_it=m_Bones.begin(); b_it!=m_Bones.end(); b_it++){
CBone* B = *b_it;
BoneIt n_it = std::find_if(load_bones.begin(),load_bones.end(),fBoneNameEQ(B->Name()));
if (n_it!=load_bones.end())
{
B->CopyData (*n_it);
}else{
ELog.Msg (mtError,"Can't find bone: '%s'.",*(*b_it)->Name());
bRes = false;
// break;
}
}
for (BoneIt n_it=load_bones.begin(); n_it!=load_bones.end(); n_it++)
xr_delete(*n_it);
load_bones.clear();
}else{
ELog.Msg (mtError,"Empty bone list.");
bRes = false;
}
// load bone part
if (F.find_chunk(EOBJ_CHUNK_BONEPARTS2)){
shared_str buf;
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())
ELog.Msg (mtError,"Invalid bone parts. Found missing or duplicate bone.");
}else{
ELog.Msg (mtError,"Can't load bone parts. Invalid version.");
}
return bRes;
}
void st_LevelOptions::Read(IReader& F)
{
R_ASSERT(F.find_chunk(CHUNK_LO_VERSION));
DWORD vers = F.r_u32( );
if( vers < 0x00000008 )
{
ELog.DlgMsg( mtError, "Skipping bad version of level options." );
return;
}
R_ASSERT(F.find_chunk(CHUNK_LO_NAMES));
F.r_stringZ (m_FNLevelPath);
if (F.find_chunk(CHUNK_LO_PREFIX)) F.r_stringZ (m_LevelPrefix);
R_ASSERT(F.find_chunk(CHUNK_LO_BOP));
F.r_stringZ (m_BOPText);
if (F.find_chunk(CHUNK_LO_MAP_VER))
F.r_stringZ (m_map_version);
vers = 0;
if (F.find_chunk(CHUNK_LO_BP_VERSION))
vers = F.r_u32( );
if (CURRENT_LEVELOP_BP_VERSION==vers){
if (F.find_chunk(CHUNK_BUILD_PARAMS))
F.r(&m_BuildParams, sizeof(m_BuildParams));
}else{
ELog.DlgMsg (mtError, "Skipping bad version of build params.");
m_BuildParams.Init();
}
if (F.find_chunk(CHUNK_LIGHT_QUALITY))
{
m_LightHemiQuality = F.r_u8();
m_LightSunQuality = F.r_u8();
}
if (F.find_chunk(CHUNK_MAP_USAGE))
{
if(vers > 0x00000008)
{
m_mapUsage.m_GameType.assign (F.r_u16());
}else
{
m_mapUsage.m_GameType.zero ();
m_mapUsage.m_GameType.set (eGameIDDeathmatch , F.r_s32());
m_mapUsage.m_GameType.set (eGameIDTeamDeathmatch, F.r_s32());
m_mapUsage.m_GameType.set (eGameIDArtefactHunt, F.r_s32());
}
}
}
bool ESceneObjectTools::Load(IReader& F)
{
u16 version = 0;
if(F.r_chunk(CHUNK_VERSION,&version)){
if( version!=OBJECT_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_APPEND_RANDOM)){
F.r_fvector3(m_AppendRandomMinScale);
F.r_fvector3(m_AppendRandomMaxScale);
F.r_fvector3(m_AppendRandomMinRotation);
F.r_fvector3(m_AppendRandomMaxRotation);
int cnt = F.r_u32();
if (cnt){
shared_str buf;
for (int i=0; i<cnt; i++){
F.r_stringZ (buf);
m_AppendRandomObjects.push_back (buf);
}
}
};
m_Flags.set(flAppendRandom,FALSE);
return true;
}
bool EDetail::Load(IReader& F)
{
// check version
R_ASSERT (F.find_chunk(DETOBJ_CHUNK_VERSION));
u32 version = F.r_u32();
if (version!=DETOBJ_VERSION){
ELog.Msg(mtError,"EDetail: unsupported version.");
return false;
}
// references
string256 buf;
R_ASSERT (F.find_chunk(DETOBJ_CHUNK_REFERENCE));
F.r_stringZ (buf,sizeof(buf));
// scale
R_ASSERT (F.find_chunk(DETOBJ_CHUNK_SCALE_LIMITS));
m_fMinScale = F.r_float(); if (fis_zero(m_fMinScale)) m_fMinScale = 0.1f;
m_fMaxScale = F.r_float(); if (m_fMaxScale<m_fMinScale) m_fMaxScale = m_fMinScale;
// density factor
if (F.find_chunk(DETOBJ_CHUNK_DENSITY_FACTOR))
m_fDensityFactor= F.r_float();
if (F.find_chunk(DETOBJ_CHUNK_FLAGS))
m_Flags.assign (F.r_u32());
// update object
return Update(buf);
}
bool EParticlesObject::Load(IReader& F)
{
u32 version = 0;
R_ASSERT(F.r_chunk(CPSOBJECT_CHUNK_VERSION,&version));
if( version!=CPSOBJECT_VERSION ){
ELog.DlgMsg( mtError, "PSObject: Unsupported version.");
return false;
}
inherited::Load(F);
R_ASSERT(F.find_chunk(CPSOBJECT_CHUNK_REFERENCE));
F.r_stringZ(m_RefName);
if (!Compile(*m_RefName)){
ELog.DlgMsg( mtError, "EParticlesObject: '%s' not found in library", *m_RefName );
return false;
}
if (F.find_chunk(CPSOBJECT_CHUNK_PARAMS)){
//. if (m_Particles) m_Particles->m_RT_Flags.set(F.r_u32());
}
return true;
}
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;
}
bool CCustomMotion::Load(IReader& F)
{
F.r_stringZ (name);
iFrameStart = F.r_u32();
iFrameEnd = F.r_u32();
fFPS = F.r_float();
return true;
}
bool CClip::Load(IReader& F)
{
R_ASSERT (F.find_chunk(EOBJ_CLIP_VERSION_CHUNK));
u16 ver = F.r_u16();
if (ver!=EOBJ_CLIP_VERSION) return false;
R_ASSERT(F.find_chunk(EOBJ_CLIP_DATA_CHUNK));
F.r_stringZ (name);
for (int k=0; k<4; k++){
F.r_stringZ (cycles[k].name);
cycles[k].slot = F.r_u16();
}
F.r_stringZ (fx.name);
fx.slot = F.r_u16();
fx_power = F.r_float();
length = F.r_float();
return true;
}
//------------------------------------------------------------------------------
// I/O part
//------------------------------------------------------------------------------
BOOL CPGDef::Load(IReader& F)
{
R_ASSERT (F.find_chunk(PGD_CHUNK_VERSION));
u16 version = F.r_u16();
if (version!=PGD_VERSION){
Log ("!Unsupported PG version. Load failed.");
return FALSE;
}
R_ASSERT (F.find_chunk(PGD_CHUNK_NAME));
F.r_stringZ (m_Name);
F.r_chunk (PGD_CHUNK_FLAGS,&m_Flags);
if (F.find_chunk(PGD_CHUNK_EFFECTS)){
m_Effects.resize(F.r_u32());
for (EffectIt it=m_Effects.begin(); it!=m_Effects.end(); it++){
*it = xr_new<SEffect>();
F.r_stringZ ((*it)->m_EffectName);
F.r_stringZ ((*it)->m_OnPlayChildName);
F.r_stringZ ((*it)->m_OnBirthChildName);
F.r_stringZ ((*it)->m_OnDeadChildName);
(*it)->m_Time0 = F.r_float();
(*it)->m_Time1 = F.r_float();
(*it)->m_Flags.assign (F.r_u32());
}
}else{ //.??? убрать через некоторое время
R_ASSERT (F.find_chunk(PGD_CHUNK_EFFECTS2));
m_Effects.resize(F.r_u32());
for (EffectIt it=m_Effects.begin(); it!=m_Effects.end(); it++){
*it = xr_new<SEffect>();
F.r_stringZ ((*it)->m_EffectName);
F.r_stringZ ((*it)->m_OnPlayChildName);
(*it)->m_Time0 = F.r_float();
(*it)->m_Time1 = F.r_float();
(*it)->m_Flags.assign (F.r_u32());
}
}
if (F.find_chunk(PGD_CHUNK_TIME_LIMIT)){
m_fTimeLimit= F.r_float();
}
#ifdef _EDITOR
if (F.find_chunk(PGD_CHUNK_OWNER)){
F.r_stringZ (m_OwnerName);
F.r_stringZ (m_ModifName);
F.r (&m_CreateTime,sizeof(m_CreateTime));
F.r (&m_ModifTime,sizeof(m_ModifTime));
}
#endif
return TRUE;
}
void CMapLocation::load(IReader &stream)
{
u16 c = stream.r_u16();
xr_string hint;
stream.r_stringZ(hint);
SetHint (hint.c_str());
SetRefCount (c);
m_flags.flags = stream.r_u32 ();
}
bool ESceneAIMapTool::LoadStream(IReader& F)
{
inherited::LoadStream (F);
u16 version = 0;
R_ASSERT(F.r_chunk(AIMAP_CHUNK_VERSION,&version));
if( version!=AIMAP_VERSION ){
ELog.DlgMsg( mtError, "AIMap: Unsupported version.");
return false;
}
R_ASSERT(F.find_chunk(AIMAP_CHUNK_FLAGS));
F.r (&m_Flags,sizeof(m_Flags));
R_ASSERT(F.find_chunk(AIMAP_CHUNK_BOX));
F.r (&m_AIBBox,sizeof(m_AIBBox));
R_ASSERT(F.find_chunk(AIMAP_CHUNK_PARAMS));
F.r (&m_Params,sizeof(m_Params));
R_ASSERT(F.find_chunk(AIMAP_CHUNK_NODES));
m_Nodes.resize (F.r_u32());
for (AINodeIt it=m_Nodes.begin(); it!=m_Nodes.end(); it++){
*it = xr_new<SAINode>();
(*it)->LoadStream (F,this);
}
DenumerateNodes ();
if (F.find_chunk(AIMAP_CHUNK_INTERNAL_DATA)){
m_VisRadius = F.r_float();
m_BrushSize = F.r_u32();
}
if (F.find_chunk(AIMAP_CHUNK_INTERNAL_DATA2)){
m_SmoothHeight = F.r_float();
}
// snap objects
if (F.find_chunk(AIMAP_CHUNK_SNAP_OBJECTS)){
shared_str buf;
int cnt = F.r_u32();
if (cnt){
for (int i=0; i<cnt; i++){
F.r_stringZ (buf);
CCustomObject* O = Scene->FindObjectByName(buf.c_str(),OBJCLASS_SCENEOBJECT);
if (!O) ELog.Msg(mtError,"AIMap: Can't find snap object '%s'.",buf.c_str());
else m_SnapObjects.push_back(O);
}
}
}
hash_FillFromNodes ();
return true;
}
bool CGroupObject::LoadStream(IReader& F)
{
u16 version=0;
R_ASSERT(F.r_chunk(GROUPOBJ_CHUNK_VERSION,&version));
if (version<0x0011)
{
ELog.DlgMsg( mtError, "CGroupObject: unsupported file version. Object can't load.");
return false;
}
CCustomObject::LoadStream(F);
Flags32 tmp_flags; tmp_flags.zero();
if(version<0x0012)
F.r_chunk(GROUPOBJ_CHUNK_FLAGS,&tmp_flags);
// objects
if (tmp_flags.test(1<<0))
{ //old format, opened group
ELog.DlgMsg( mtError, "old format, opened group");
return false;
/*
R_ASSERT(F.find_chunk(GROUPOBJ_CHUNK_OPEN_OBJECT_LIST));
u32 cnt = F.r_u32();
for (u32 k=0; k<cnt; ++k)
{
m_ObjectsInGroup.resize (m_ObjectsInGroup.size()+1);
F.r_stringZ (m_ObjectsInGroup.back().ObjectName);
}
*/
}else
{
Scene->ReadObjectsStream(F,GROUPOBJ_CHUNK_OBJECT_LIST,AppendObjectLoadCB,0);
}
VERIFY(m_ObjectsInGroup.size());
if (F.find_chunk(GROUPOBJ_CHUNK_REFERENCE))
{
shared_str rn;
F.r_stringZ (rn);
SetRefName(rn.c_str());
}
if(version<0x0012)
{
for (ObjectsInGroup::iterator it=m_ObjectsInGroup.begin(); it!=m_ObjectsInGroup.end(); ++it)
if(it->pObject)
{
it->pObject->m_CO_Flags.set(flObjectInGroup, TRUE);
it->pObject->m_CO_Flags.set(flObjectInGroupUnique, TRUE);
}
}
return true;
}
bool ESceneCustomMTools::Load(IReader& F)
{
if (F.find_chunk(CHUNK_TOOLS_TAG)){
F.r_stringZ (m_ModifName);
F.r (&m_ModifTime,sizeof(m_ModifTime));
}else{
m_ModifName = "";
m_ModifTime = 0;
}
return true;
}
void STextureParams::Load(IReader& F)
{
R_ASSERT(F.find_chunk(THM_CHUNK_TEXTUREPARAM));
F.r (&fmt,sizeof(ETFormat));
flags.assign(F.r_u32());
border_color= F.r_u32();
fade_color = F.r_u32();
fade_amount = F.r_u32();
mip_filter = F.r_u32();
width = F.r_u32();
height = F.r_u32();
if (F.find_chunk(THM_CHUNK_TEXTURE_TYPE)){
type = (ETType)F.r_u32();
}
if (F.find_chunk(THM_CHUNK_DETAIL_EXT)){
F.r_stringZ(detail_name);
detail_scale = F.r_float();
}
if (F.find_chunk(THM_CHUNK_MATERIAL)){
material = (ETMaterial)F.r_u32 ();
material_weight = F.r_float ();
}
if (F.find_chunk(THM_CHUNK_BUMP)){
bump_virtual_height = F.r_float ();
bump_mode = (ETBumpMode)F.r_u32 ();
if (bump_mode<STextureParams::tbmNone){
bump_mode = STextureParams::tbmNone; //.. временно (до полного убирания Autogen)
}
F.r_stringZ (bump_name);
}
if (F.find_chunk(THM_CHUNK_EXT_NORMALMAP))
F.r_stringZ (ext_normal_map_name);
if (F.find_chunk(THM_CHUNK_FADE_DELAY))
fade_delay = F.r_u8();
}
void __fastcall TfrmText::ebLoadClick(TObject *Sender)
{
xr_string fn;
if (EFS.GetOpenName(_import_,fn,false,NULL,2)){
xr_string buf;
IReader* F = FS.r_open(fn.c_str());
F->r_stringZ (buf);
mmText->Text = buf.c_str();
FS.r_close (F);
ebOk->Enabled = true;
}
}
void SGameMtlPair::Load(IReader& fs)
{
shared_str buf;
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_PAIR));
mtl0 = fs.r_u32();
mtl1 = fs.r_u32();
ID = fs.r_u32();
ID_parent = fs.r_u32();
OwnProps.assign (fs.r_u32());
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_BREAKING));
fs.r_stringZ (buf); BreakingSounds = *buf;
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_STEP));
fs.r_stringZ (buf); StepSounds = *buf;
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_COLLIDE));
fs.r_stringZ (buf); CollideSounds = *buf;
fs.r_stringZ (buf); CollideParticles= *buf;
fs.r_stringZ (buf); CollideMarks = *buf;
}
void CBone::Load_1(IReader& F)
{
R_ASSERT(F.find_chunk(BONE_CHUNK_VERSION));
u16 ver = F.r_u16();
if ((ver!=0x0001)&&(ver!=BONE_VERSION))
return;
R_ASSERT(F.find_chunk(BONE_CHUNK_DEF));
F.r_stringZ (name); xr_strlwr(name);
F.r_stringZ (parent_name); xr_strlwr(parent_name);
F.r_stringZ (wmap);
R_ASSERT(F.find_chunk(BONE_CHUNK_BIND_POSE));
F.r_fvector3 (rest_offset);
F.r_fvector3 (rest_rotate);
rest_length = F.r_float();
if (ver==0x0001)
std::swap (rest_rotate.x,rest_rotate.y);
LoadData (F);
}
void SGameMtlPair::Load(IReader& fs)
{
shared_str buf;
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_PAIR));
mtl0 = fs.r_u32();
mtl1 = fs.r_u32();
ID = fs.r_u32();
ID_parent = fs.r_u32();
u32 own_mask = fs.r_u32();
if (GAMEMTL_NONE_ID==ID_parent) OwnProps.one ();
else OwnProps.assign (own_mask);
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_BREAKING));
fs.r_stringZ (buf); BreakingSounds = buf.size()?*buf:"";
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_STEP));
fs.r_stringZ (buf); StepSounds = buf.size()?*buf:"";
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_COLLIDE));
fs.r_stringZ (buf); CollideSounds = buf.size()?*buf:"";
fs.r_stringZ (buf); CollideParticles= buf.size()?*buf:"";
fs.r_stringZ (buf); CollideMarks = buf.size()?*buf:"";
}
void CLAItem::Load(IReader& F)
{
R_ASSERT(F.find_chunk(CHUNK_ITEM_COMMON));
F.r_stringZ (cName);
fFPS = F.r_float();
iFrameCount = F.r_u32();
int key_cnt,key;
R_ASSERT(F.find_chunk(CHUNK_ITEM_KEYS));
key_cnt = F.r_u32();
for (int i=0; i<key_cnt; i++){
key = F.r_u32 ();
Keys[key] = F.r_u32();
}
}
bool ESoundEnvironment::LoadStream(IReader& F)
{
u16 version = 0;
R_ASSERT(F.r_chunk(SOUND_CHUNK_VERSION,&version));
if(version!=SOUND_ENV_VERSION){
ELog.DlgMsg( mtError, "ESoundSource: Unsupported version.");
return false;
}
inherited::LoadStream (F);
R_ASSERT(F.find_chunk(SOUND_CHUNK_ENV_REFS));
F.r_stringZ (m_EnvInner);
F.r_stringZ (m_EnvOuter);
return true;
}
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::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 CLight::Load(IReader& F)
{
u32 version = 0;
string1024 buf;
R_ASSERT(F.r_chunk(LIGHT_CHUNK_VERSION,&version));
if((version!=0x0010)&&(version!=LIGHT_VERSION)){
ELog.DlgMsg( mtError, "CLight: Unsupported version.");
return false;
}
CCustomObject::Load(F);
if (F.find_chunk(LIGHT_CHUNK_PARAMS)){
m_Type = (ELight::EType)F.r_u32();
F.r_fcolor (m_Color);
m_Brightness = F.r_float();
m_Range = F.r_float();
m_Attenuation0 = F.r_float();
m_Attenuation1 = F.r_float();
m_Attenuation2 = F.r_float();
m_Cone = F.r_float();
m_VirtualSize = F.r_float();
}else{
R_ASSERT(F.find_chunk(LIGHT_CHUNK_D3D_PARAMS));
Flight d3d;
F.r (&d3d,sizeof(d3d));
m_Type = (ELight::EType)d3d.type;
m_Color.set (d3d.diffuse);
PPosition = d3d.position;
m_Range = d3d.range;
m_Attenuation0 = d3d.attenuation0;
m_Attenuation1 = d3d.attenuation1;
m_Attenuation2 = d3d.attenuation2;
m_Cone = d3d.phi;
R_ASSERT(F.r_chunk(LIGHT_CHUNK_BRIGHTNESS,&m_Brightness));
}
R_ASSERT(F.r_chunk(LIGHT_CHUNK_USE_IN_D3D,&m_UseInD3D));
if(version==0x0010){
if (F.find_chunk(LIGHT_CHUNK_ROTATE)){
F.r_fvector3(FRotation);
}else{
FRotation.set(0,0,0);
}
}
if (F.find_chunk(LIGHT_CHUNK_FLAG)) F.r(&m_Flags.flags,sizeof(m_Flags));
if (F.find_chunk(LIGHT_CHUNK_LCONTROL)) F.r(&m_LControl,sizeof(m_LControl));
if (D3DLIGHT_DIRECTIONAL==m_Type){
ESceneLightTools* lt = dynamic_cast<ESceneLightTools*>(ParentTools); VERIFY(lt);
lt->m_SunShadowDir.set(FRotation.x,FRotation.y);
ELog.DlgMsg( mtError, "CLight: Can't load sun.");
return false;
}
if (F.find_chunk(LIGHT_CHUNK_ANIMREF)){
F.r_stringZ(buf,sizeof(buf));
m_pAnimRef = LALib.FindItem(buf);
if (!m_pAnimRef) ELog.Msg(mtError, "Can't find light animation: %s",buf);
}
if (F.find_chunk(LIGHT_CHUNK_FALLOFF_TEXTURE)){
F.r_stringZ(m_FalloffTex);
}
if (F.find_chunk(LIGHT_CHUNK_FUZZY_DATA)){
m_FuzzyData = xr_new<SFuzzyData>();
m_FuzzyData->Load(F);
m_Flags.set(ELight::flPointFuzzy,TRUE);
}else{
m_Flags.set(ELight::flPointFuzzy,FALSE);
}
UpdateTransform ();
return true;
}
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);
}
