void CPatternFunction::vfLoadEF(LPCSTR caFileName)
{
string_path caPath;
if (!FS.exist(caPath,"$game_ai$",caFileName)) {
Msg ("! Evaluation function : File not found \"%s\"",caPath);
R_ASSERT (false);
return;
}
IReader *F = FS.r_open(caPath);
F->r (&m_tEFHeader,sizeof(SEFHeader));
if (EFC_VERSION != m_tEFHeader.dwBuilderVersion) {
FS.r_close (F);
Msg ("! Evaluation function (%s) : Not supported version of the Evaluation Function Contructor",caPath);
R_ASSERT (false);
return;
}
F->r (&m_dwVariableCount,sizeof(m_dwVariableCount));
m_dwaAtomicFeatureRange = xr_alloc<u32>(m_dwVariableCount);
ZeroMemory (m_dwaAtomicFeatureRange,m_dwVariableCount*sizeof(u32));
u32 *m_dwaAtomicIndexes = xr_alloc<u32>(m_dwVariableCount);
ZeroMemory (m_dwaAtomicIndexes,m_dwVariableCount*sizeof(u32));
for (u32 i=0; i<m_dwVariableCount; ++i) {
F->r(m_dwaAtomicFeatureRange + i,sizeof(u32));
if (i)
m_dwaAtomicIndexes[i] = m_dwaAtomicIndexes[i-1] + m_dwaAtomicFeatureRange[i-1];
}
m_dwaVariableTypes = xr_alloc<u32>(m_dwVariableCount);
F->r (m_dwaVariableTypes,m_dwVariableCount*sizeof(u32));
F->r (&m_dwFunctionType,sizeof(u32));
F->r (&m_fMinResultValue,sizeof(float));
F->r (&m_fMaxResultValue,sizeof(float));
F->r (&m_dwPatternCount,sizeof(m_dwPatternCount));
m_tpPatterns = xr_alloc<SPattern>(m_dwPatternCount);
m_dwaPatternIndexes = xr_alloc<u32>(m_dwPatternCount);
ZeroMemory (m_dwaPatternIndexes,m_dwPatternCount*sizeof(u32));
m_dwParameterCount = 0;
for (u32 i=0; i<m_dwPatternCount; ++i) {
if (i)
m_dwaPatternIndexes[i] = m_dwParameterCount;
F->r (&(m_tpPatterns[i].dwCardinality),sizeof(m_tpPatterns[i].dwCardinality));
m_tpPatterns[i].dwaVariableIndexes = xr_alloc<u32>(m_tpPatterns[i].dwCardinality);
F->r (m_tpPatterns[i].dwaVariableIndexes,m_tpPatterns[i].dwCardinality*sizeof(u32));
u32 m_dwComplexity = 1;
for (int j=0; j<(int)m_tpPatterns[i].dwCardinality; ++j)
m_dwComplexity *= m_dwaAtomicFeatureRange[m_tpPatterns[i].dwaVariableIndexes[j]];
m_dwParameterCount += m_dwComplexity;
}
m_faParameters = xr_alloc<float>(m_dwParameterCount);
F->r (m_faParameters,m_dwParameterCount*sizeof(float));
FS.r_close (F);
m_dwaVariableValues = xr_alloc<u32>(m_dwVariableCount);
xr_free (m_dwaAtomicIndexes);
ef_storage().m_fpaBaseFunctions[m_dwFunctionType] = this;
_splitpath (caPath,0,0,m_caName,0);
// Msg ("* Evaluation function \"%s\" is successfully loaded",m_caName);
}
shell_root CPHShellSplitterHolder::ElementSingleSplit(const element_fracture &split_elem,const CPHElement* source_element)
{
//const CPHShellSplitter& splitter=m_splitters[aspl];
//CPHElement* element=m_pShell->elements[splitter.m_element];
CPhysicsShell *new_shell_last=P_create_Shell();
CPHShell *new_shell_last_desc=smart_cast<CPHShell*>(new_shell_last);
new_shell_last->mXFORM.set(m_pShell->mXFORM); const u16 start_joint=split_elem.second.m_start_jt_num;
R_ASSERT(_valid(new_shell_last->mXFORM));
const u16 end_joint=split_elem.second.m_end_jt_num;
//it is not right for multiple joints attached to the unsplited part becource all these need to be reattached
if(start_joint!=end_joint)
{
JOINT_STORAGE& joints=m_pShell->joints;
JOINT_I i=joints.begin()+ start_joint,e=joints.begin()+ end_joint;
for(;i!=e;++i)
{
CPHJoint* joint=(*i);
if(joint->PFirst_element()==source_element)
{
IKinematics* K = m_pShell->PKinematics();
dVector3 safe_pos1, safe_pos2;
dQuaternion safe_q1, safe_q2;
CPhysicsElement* el1=cast_PhysicsElement(split_elem.first),*el2=joint->PSecond_element();
dBodyID body1=el1->get_body(), body2=el2->get_body();
dVectorSet(safe_pos1,dBodyGetPosition(body1));
dVectorSet(safe_pos2,dBodyGetPosition(body2));
dQuaternionSet(safe_q1,dBodyGetQuaternion(body1));
dQuaternionSet(safe_q2,dBodyGetQuaternion(body2));
//m_pShell->PlaceBindToElForms();
K->LL_GetBindTransform(bones_bind_forms);
el1->SetTransform(bones_bind_forms[el1->m_SelfID]);
el2->SetTransform(bones_bind_forms[el2->m_SelfID]);
joint->ReattachFirstElement(split_elem.first);
dVectorSet(const_cast<dReal*>(dBodyGetPosition(body1)),safe_pos1);
dVectorSet(const_cast<dReal*>(dBodyGetPosition(body2)),safe_pos2);
dQuaternionSet(const_cast<dReal*>(dBodyGetQuaternion(body1)),safe_q1);
dQuaternionSet(const_cast<dReal*>(dBodyGetQuaternion(body2)),safe_q2);
dBodySetPosition(body1,safe_pos1[0],safe_pos1[1],safe_pos1[2]);
dBodySetPosition(body2,safe_pos2[0],safe_pos2[1],safe_pos2[2]);
dBodySetQuaternion(body1,safe_q1);
dBodySetQuaternion(body2,safe_q2);
}
}
// m_pShell->joints[split_elem.second.m_start_jt_num]->ReattachFirstElement(split_elem.first);
}
//the last new shell will have all splitted old elements end joints and one new element reattached to old joint
//m_splitters.erase(m_splitters.begin()+aspl);
//now aspl points to the next splitter
if((split_elem.first)->FracturesHolder())//if this element can be splitted add a splitter for it
new_shell_last_desc->AddSplitter(CPHShellSplitter::splElement,0,u16(-1));//
new_shell_last_desc->add_Element(split_elem.first);
//pass splitters taking into account that one element was olready added
PassEndSplitters(split_elem.second,new_shell_last_desc,0,0);
InitNewShell(new_shell_last_desc);
m_pShell->PassEndElements(split_elem.second.m_start_el_num,split_elem.second.m_end_el_num,new_shell_last_desc);
m_pShell->PassEndJoints(split_elem.second.m_start_jt_num,split_elem.second.m_end_jt_num,new_shell_last_desc);
new_shell_last_desc->set_PhysicsRefObject(0);
///////////////////temporary for initialization set old Kinematics in new shell/////////////////
new_shell_last->set_Kinematics(m_pShell->PKinematics());
new_shell_last_desc->AfterSetActive();
new_shell_last->set_Kinematics(NULL);
VERIFY2(split_elem.second.m_bone_id<64,"strange root");
VERIFY(_valid(new_shell_last->mXFORM));
VERIFY(dBodyStateValide(source_element->get_bodyConst()));
VERIFY(dBodyStateValide(split_elem.first->get_body()));
new_shell_last->set_ObjectContactCallback(NULL);
new_shell_last->set_PhysicsRefObject(NULL);
return mk_pair(new_shell_last,split_elem.second.m_bone_id);
}
void CCustomZone::Load(LPCSTR section)
{
inherited::Load(section);
m_iDisableHitTime = pSettings->r_s32(section, "disable_time");
m_iDisableHitTimeSmall = pSettings->r_s32(section, "disable_time_small");
m_iDisableIdleTime = pSettings->r_s32(section, "disable_idle_time");
m_fHitImpulseScale = pSettings->r_float(section, "hit_impulse_scale");
m_fEffectiveRadius = pSettings->r_float(section, "effective_radius");
m_eHitTypeBlowout = ALife::g_tfString2HitType(pSettings->r_string(section, "hit_type"));
m_zone_flags.set(eIgnoreNonAlive, pSettings->r_bool(section, "ignore_nonalive"));
m_zone_flags.set(eIgnoreSmall, pSettings->r_bool(section, "ignore_small"));
m_zone_flags.set(eIgnoreArtefact, pSettings->r_bool(section, "ignore_artefacts"));
m_zone_flags.set(eVisibleByDetector,pSettings->r_bool(section, "visible_by_detector"));
//загрузить времена для зоны
m_StateTime[eZoneStateIdle] = -1;
m_StateTime[eZoneStateAwaking] = pSettings->r_s32(section, "awaking_time");
m_StateTime[eZoneStateBlowout] = pSettings->r_s32(section, "blowout_time");
m_StateTime[eZoneStateAccumulate] = pSettings->r_s32(section, "accamulate_time");
//////////////////////////////////////////////////////////////////////////
ISpatial* self = smart_cast<ISpatial*> (this);
if (self) self->spatial.type |= (STYPE_COLLIDEABLE|STYPE_SHAPE);
//////////////////////////////////////////////////////////////////////////
LPCSTR sound_str = NULL;
if(pSettings->line_exist(section,"idle_sound"))
{
sound_str = pSettings->r_string(section,"idle_sound");
m_idle_sound.create(sound_str, st_Effect,sg_SourceType);
}
if(pSettings->line_exist(section,"accum_sound"))
{
sound_str = pSettings->r_string(section,"accum_sound");
m_accum_sound.create(sound_str, st_Effect,sg_SourceType);
}
if(pSettings->line_exist(section,"awake_sound"))
{
sound_str = pSettings->r_string(section,"awake_sound");
m_awaking_sound.create(sound_str, st_Effect,sg_SourceType);
}
if(pSettings->line_exist(section,"blowout_sound"))
{
sound_str = pSettings->r_string(section,"blowout_sound");
m_blowout_sound.create(sound_str, st_Effect,sg_SourceType);
}
if(pSettings->line_exist(section,"hit_sound"))
{
sound_str = pSettings->r_string(section,"hit_sound");
m_hit_sound.create(sound_str, st_Effect,sg_SourceType);
}
if(pSettings->line_exist(section,"entrance_sound"))
{
sound_str = pSettings->r_string(section,"entrance_sound");
m_entrance_sound.create(sound_str, st_Effect,sg_SourceType);
}
if(pSettings->line_exist(section,"idle_particles"))
m_sIdleParticles = pSettings->r_string(section,"idle_particles");
if(pSettings->line_exist(section,"blowout_particles"))
m_sBlowoutParticles = pSettings->r_string(section,"blowout_particles");
if(pSettings->line_exist(section,"accum_particles"))
m_sAccumParticles = pSettings->r_string(section,"accum_particles");
if(pSettings->line_exist(section,"awake_particles"))
m_sAwakingParticles = pSettings->r_string(section,"awake_particles");
if(pSettings->line_exist(section,"entrance_small_particles"))
m_sEntranceParticlesSmall = pSettings->r_string(section,"entrance_small_particles");
if(pSettings->line_exist(section,"entrance_big_particles"))
m_sEntranceParticlesBig = pSettings->r_string(section,"entrance_big_particles");
if(pSettings->line_exist(section,"hit_small_particles"))
m_sHitParticlesSmall = pSettings->r_string(section,"hit_small_particles");
if(pSettings->line_exist(section,"hit_big_particles"))
m_sHitParticlesBig = pSettings->r_string(section,"hit_big_particles");
if(pSettings->line_exist(section,"idle_small_particles"))
m_sIdleObjectParticlesBig = pSettings->r_string(section,"idle_big_particles");
if(pSettings->line_exist(section,"idle_big_particles"))
m_sIdleObjectParticlesSmall = pSettings->r_string(section,"idle_small_particles");
if(pSettings->line_exist(section,"idle_particles_dont_stop"))
m_bIdleObjectParticlesDontStop=pSettings->r_bool(section,"idle_particles_dont_stop");
if(pSettings->line_exist(section,"postprocess"))
{
m_effector = xr_new<CZoneEffector>();
m_effector->Load (pSettings->r_string(section,"postprocess"));
};
if(pSettings->line_exist(section,"blowout_particles_time"))
{
m_dwBlowoutParticlesTime = pSettings->r_u32(section,"blowout_particles_time");
if (s32(m_dwBlowoutParticlesTime)>m_StateTime[eZoneStateBlowout]) {
m_dwBlowoutParticlesTime=m_StateTime[eZoneStateBlowout];
Msg("! ERROR: invalid 'blowout_particles_time' in '%s'",section);
}
}
else
m_dwBlowoutParticlesTime = 0;
if(pSettings->line_exist(section,"blowout_light_time"))
{
m_dwBlowoutLightTime = pSettings->r_u32(section,"blowout_light_time");
if (s32(m_dwBlowoutLightTime)>m_StateTime[eZoneStateBlowout]) {
m_dwBlowoutLightTime=m_StateTime[eZoneStateBlowout];
Msg("! ERROR: invalid 'blowout_light_time' in '%s'",section);
}
}
else
m_dwBlowoutLightTime = 0;
if(pSettings->line_exist(section,"blowout_sound_time"))
{
m_dwBlowoutSoundTime = pSettings->r_u32(section,"blowout_sound_time");
if (s32(m_dwBlowoutSoundTime)>m_StateTime[eZoneStateBlowout]) {
m_dwBlowoutSoundTime=m_StateTime[eZoneStateBlowout];
Msg("! ERROR: invalid 'blowout_sound_time' in '%s'",section);
}
}
else
m_dwBlowoutSoundTime = 0;
if(pSettings->line_exist(section,"blowout_explosion_time")) {
m_dwBlowoutExplosionTime = pSettings->r_u32(section,"blowout_explosion_time");
if (s32(m_dwBlowoutExplosionTime)>m_StateTime[eZoneStateBlowout]) {
m_dwBlowoutExplosionTime=m_StateTime[eZoneStateBlowout];
Msg("! ERROR: invalid 'blowout_explosion_time' in '%s'",section);
}
}
else
m_dwBlowoutExplosionTime = 0;
m_zone_flags.set(eBlowoutWind, pSettings->r_bool(section,"blowout_wind"));
if( m_zone_flags.test(eBlowoutWind) ){
m_dwBlowoutWindTimeStart = pSettings->r_u32(section,"blowout_wind_time_start");
m_dwBlowoutWindTimePeak = pSettings->r_u32(section,"blowout_wind_time_peak");
m_dwBlowoutWindTimeEnd = pSettings->r_u32(section,"blowout_wind_time_end");
R_ASSERT(m_dwBlowoutWindTimeStart < m_dwBlowoutWindTimePeak);
R_ASSERT(m_dwBlowoutWindTimePeak < m_dwBlowoutWindTimeEnd);
if((s32)m_dwBlowoutWindTimeEnd < m_StateTime[eZoneStateBlowout]){
m_dwBlowoutWindTimeEnd =u32( m_StateTime[eZoneStateBlowout]-1);
Msg("! ERROR: invalid 'blowout_wind_time_end' in '%s'",section);
}
m_fBlowoutWindPowerMax = pSettings->r_float(section,"blowout_wind_power");
}
//загрузить параметры световой вспышки от взрыва
m_zone_flags.set(eBlowoutLight, pSettings->r_bool (section, "blowout_light"));
if(m_zone_flags.test(eBlowoutLight) ){
sscanf(pSettings->r_string(section,"light_color"), "%f,%f,%f", &m_LightColor.r, &m_LightColor.g, &m_LightColor.b);
m_fLightRange = pSettings->r_float(section,"light_range");
m_fLightTime = pSettings->r_float(section,"light_time");
m_fLightTimeLeft = 0;
m_fLightHeight = pSettings->r_float(section,"light_height");
}
//загрузить параметры idle подсветки
m_zone_flags.set(eIdleLight, pSettings->r_bool (section, "idle_light"));
if( m_zone_flags.test(eIdleLight) )
{
m_fIdleLightRange = pSettings->r_float(section,"idle_light_range");
m_fIdleLightRangeDelta = pSettings->r_float(section,"idle_light_range_delta");
LPCSTR light_anim = pSettings->r_string(section,"idle_light_anim");
m_pIdleLAnim = LALib.FindItem(light_anim);
m_fIdleLightHeight = pSettings->r_float(section,"idle_light_height");
}
//загрузить параметры для разбрасывания артефактов
m_zone_flags.set(eSpawnBlowoutArtefacts, pSettings->r_bool(section,"spawn_blowout_artefacts"));
if( m_zone_flags.test(eSpawnBlowoutArtefacts) )
{
m_fArtefactSpawnProbability = pSettings->r_float (section,"artefact_spawn_probability");
if(pSettings->line_exist(section,"artefact_spawn_particles"))
m_sArtefactSpawnParticles = pSettings->r_string(section,"artefact_spawn_particles");
else
m_sArtefactSpawnParticles = NULL;
if(pSettings->line_exist(section,"artefact_born_sound"))
{
sound_str = pSettings->r_string(section,"artefact_born_sound");
m_ArtefactBornSound.create(sound_str, st_Effect,sg_SourceType);
}
m_fThrowOutPower = pSettings->r_float (section, "throw_out_power");
m_fArtefactSpawnHeight = pSettings->r_float (section, "artefact_spawn_height");
LPCSTR l_caParameters = pSettings->r_string(section, "artefacts");
u16 m_wItemCount = (u16)_GetItemCount(l_caParameters);
R_ASSERT2 (!(m_wItemCount & 1),"Invalid number of parameters in string 'artefacts' in the 'system.ltx'!");
m_wItemCount >>= 1;
m_ArtefactSpawn.clear();
string512 l_caBuffer;
float total_probability = 0.f;
m_ArtefactSpawn.resize(m_wItemCount);
for (u16 i=0; i<m_wItemCount; ++i)
{
ARTEFACT_SPAWN& artefact_spawn = m_ArtefactSpawn[i];
artefact_spawn.section = _GetItem(l_caParameters,i << 1,l_caBuffer);
artefact_spawn.probability = (float)atof(_GetItem(l_caParameters,(i << 1) | 1,l_caBuffer));
total_probability += artefact_spawn.probability;
}
R_ASSERT3(!fis_zero(total_probability), "The probability of artefact spawn is zero!",*cName());
//нормализировать вероятности
for(i=0; i<m_ArtefactSpawn.size(); ++i)
{
m_ArtefactSpawn[i].probability = m_ArtefactSpawn[i].probability/total_probability;
}
}
void CHW::CreateD3D ()
{
#ifndef DEDICATED_SERVER
LPCSTR _name = "d3d9.dll";
#else
LPCSTR _name = "xrd3d9-null.dll";
#endif
hD3D9 = LoadLibrary(_name);
R_ASSERT2 (hD3D9,"Can't find 'd3d9.dll'\nPlease install latest version of DirectX before running this program");
typedef IDirect3D9 * WINAPI _Direct3DCreate9(UINT SDKVersion);
_Direct3DCreate9* createD3D = (_Direct3DCreate9*)GetProcAddress(hD3D9,"Direct3DCreate9"); R_ASSERT(createD3D);
this->pD3D = createD3D( D3D_SDK_VERSION );
R_ASSERT2 (this->pD3D,"Please install DirectX 9.0c");
}
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);
}
bool ESceneAIMapTool::LoadLTX(CInifile& ini)
{
R_ASSERT(0);
return true;
}
void xrCompressor::CompressOne(LPCSTR path)
{
filesTOTAL ++;
if (testSKIP(path))
{
filesSKIP ++;
printf (" - a SKIP");
Msg ("%-80s - SKIP",path);
return;
}
string_path fn;
strconcat (sizeof(fn), fn, target_name.c_str(), "\\", path);
if (::GetFileAttributes(fn)==u32(-1))
{
filesSKIP ++;
printf (" - CAN'T OPEN");
Msg ("%-80s - CAN'T OPEN",path);
return;
}
IReader* src = FS.r_open (fn);
if (0==src)
{
filesSKIP ++;
printf (" - CAN'T OPEN");
Msg ("%-80s - CAN'T OPEN",path);
return;
}
bytesSRC += src->length ();
u32 c_crc32 = crc32 (src->pointer(),src->length());
u32 c_ptr = 0;
u32 c_size_real = 0;
u32 c_size_compressed = 0;
u32 a_tests = 0;
ALIAS* A = testALIAS (src,c_crc32,a_tests);
printf ("%3da ",a_tests);
if(A)
{
filesALIAS ++;
printf ("ALIAS");
Msg ("%-80s - ALIAS (%s)",path,A->path);
// Alias found
c_ptr = A->c_ptr;
c_size_real = A->c_size_real;
c_size_compressed = A->c_size_compressed;
} else
{
if (testVFS(path))
{
filesVFS ++;
// Write into BaseFS
c_ptr = fs_pack_writer->tell ();
c_size_real = src->length();
c_size_compressed = src->length();
fs_pack_writer->w (src->pointer(),c_size_real);
printf ("VFS");
Msg ("%-80s - VFS",path);
} else
{ //if(testVFS(path))
// Compress into BaseFS
c_ptr = fs_pack_writer->tell();
c_size_real = src->length();
if (0!=c_size_real)
{
u32 c_size_max = rtc_csize (src->length());
u8* c_data = xr_alloc<u8> (c_size_max);
t_compress.Begin ();
c_size_compressed = c_size_max;
if (bFast)
{
R_ASSERT(LZO_E_OK == lzo1x_1_compress ((u8*)src->pointer(),c_size_real,c_data,&c_size_compressed,c_heap));
}else
{
R_ASSERT(LZO_E_OK == lzo1x_999_compress ((u8*)src->pointer(),c_size_real,c_data,&c_size_compressed,c_heap));
}
t_compress.End ();
if ((c_size_compressed+16) >= c_size_real)
{
// Failed to compress - revert to VFS
filesVFS ++;
c_size_compressed = c_size_real;
fs_pack_writer->w (src->pointer(),c_size_real);
printf ("VFS (R)");
Msg ("%-80s - VFS (R)",path);
} else
{
// Compressed OK - optimize
if (!bFast)
{
u8* c_out = xr_alloc<u8> (c_size_real);
u32 c_orig = c_size_real;
R_ASSERT (LZO_E_OK == lzo1x_optimize (c_data,c_size_compressed,c_out,&c_orig, NULL));
R_ASSERT (c_orig == c_size_real );
xr_free (c_out);
}//bFast
fs_pack_writer->w (c_data,c_size_compressed);
printf ("%3.1f%%", 100.f*float(c_size_compressed)/float(src->length()));
Msg ("%-80s - OK (%3.1f%%)",path,100.f*float(c_size_compressed)/float(src->length()));
}
// cleanup
xr_free (c_data);
}else
{ //0!=c_size_real
filesVFS ++;
c_size_compressed = c_size_real;
printf ("VFS (R)");
Msg ("%-80s - EMPTY FILE",path);
}
}//test VFS
} //(A)
// Write description
write_file_header (path,c_crc32,c_ptr,c_size_real,c_size_compressed);
if (0==A)
{
// Register for future aliasing
ALIAS R;
R.path = xr_strdup (fn);
R.crc = c_crc32;
R.c_ptr = c_ptr;
R.c_size_real = c_size_real;
R.c_size_compressed = c_size_compressed;
aliases.insert (mk_pair(R.c_size_real,R));
}
FS.r_close (src);
}
void CRT::create (LPCSTR Name, u32 w, u32 h, D3DFORMAT f)
{
if (pSurface) return;
R_ASSERT (HW.pDevice && Name && Name[0] && w && h);
_order = CPU::GetCLK() ; //Device.GetTimerGlobal()->GetElapsed_clk();
HRESULT _hr;
dwWidth = w;
dwHeight = h;
fmt = f;
// Get caps
D3DCAPS9 caps;
R_CHK (HW.pDevice->GetDeviceCaps(&caps));
// Pow2
if (!btwIsPow2(w) || !btwIsPow2(h))
{
if (!HW.Caps.raster.bNonPow2) return;
}
// Check width-and-height of render target surface
if (w>caps.MaxTextureWidth) return;
if (h>caps.MaxTextureHeight) return;
// Select usage
u32 usage = 0;
if (D3DFMT_D24X8==fmt) usage = D3DUSAGE_DEPTHSTENCIL;
else if (D3DFMT_D24S8 ==fmt) usage = D3DUSAGE_DEPTHSTENCIL;
else if (D3DFMT_D15S1 ==fmt) usage = D3DUSAGE_DEPTHSTENCIL;
else if (D3DFMT_D16 ==fmt) usage = D3DUSAGE_DEPTHSTENCIL;
else if (D3DFMT_D16_LOCKABLE==fmt) usage = D3DUSAGE_DEPTHSTENCIL;
else if ((D3DFORMAT)MAKEFOURCC('D','F','2','4') == fmt) usage = D3DUSAGE_DEPTHSTENCIL;
else usage = D3DUSAGE_RENDERTARGET;
// Validate render-target usage
_hr = HW.pD3D->CheckDeviceFormat(
HW.DevAdapter,
HW.DevT,
HW.Caps.fTarget,
usage,
D3DRTYPE_TEXTURE,
f
);
if (FAILED(_hr)) return;
// Try to create texture/surface
Device.Resources->Evict ();
_hr = HW.pDevice->CreateTexture (w, h, 1, usage, f, D3DPOOL_DEFAULT, &pSurface,NULL);
if (FAILED(_hr) || (0==pSurface)) return;
// OK
#ifdef DEBUG
Msg ("* created RT(%s), %dx%d",Name,w,h);
#endif // DEBUG
R_CHK (pSurface->GetSurfaceLevel (0,&pRT));
pTexture = Device.Resources->_CreateTexture (Name);
pTexture->surface_set (pSurface);
}
//-----------------------------------------------------------------------
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 ESceneAIMapTool::BuildNodes(bool bFromSelectedOnly)
{
// begin
m_Nodes.reserve (1024*1024);
// Initialize hash
// hash_Initialize ();
R_ASSERT(!m_Nodes.empty());
// Estimate nodes
Fvector Pos,LevelSize;
m_AIBBox.getsize (LevelSize);
float estimated_nodes = (LevelSize.x/m_Params.fPatchSize)*(LevelSize.z/m_Params.fPatchSize);
SPBItem* pb = UI->ProgressStart(1, "Building nodes...");
// General cycle
for (int k=0; k<(int)m_Nodes.size(); k++){
SAINode* N = m_Nodes[k];
if (bFromSelectedOnly && !N->flags.is(SAINode::flSelected)) continue;
// left
if (0==N->n1){
Pos.set (N->Pos);
Pos.x -= m_Params.fPatchSize;
N->n1 = BuildNode(N->Pos,Pos,false);
}
// fwd
if (0==N->n2){
Pos.set (N->Pos);
Pos.z += m_Params.fPatchSize;
N->n2 = BuildNode(N->Pos,Pos,false);
}
// right
if (0==N->n3){
Pos.set (N->Pos);
Pos.x += m_Params.fPatchSize;
N->n3 = BuildNode(N->Pos,Pos,false);
}
// back
if (0==N->n4){
Pos.set (N->Pos);
Pos.z -= m_Params.fPatchSize;
N->n4 = BuildNode(N->Pos,Pos,false);
}
if (bFromSelectedOnly){
// select neighbour nodes
if (N->n1) N->n1->flags.set(SAINode::flSelected,TRUE);
if (N->n2) N->n2->flags.set(SAINode::flSelected,TRUE);
if (N->n3) N->n3->flags.set(SAINode::flSelected,TRUE);
if (N->n4) N->n4->flags.set(SAINode::flSelected,TRUE);
}
if (k%512==0) {
float p1 = float(k)/float(m_Nodes.size());
float p2 = float(m_Nodes.size())/estimated_nodes;
float p = 0.1f*p1+0.9f*p2;
clamp (p,0.f,1.f);
pb->Update(p);
// check need abort && redraw
if (k%32768==0) UI->RedrawScene(true);
if (UI->NeedAbort()) break;
}
}
UI->ProgressEnd(pb);
}
void ESceneAIMapTool::SmoothNodes()
{
SPBItem* pb = UI->ProgressStart(m_Nodes.size(), "Smoothing nodes...");
AINodeVec smoothed; smoothed.reserve(m_Nodes.size());
U8Vec mark; mark.assign (m_Nodes.size(),0);
int sm_nodes=0;
EnumerateNodes ();
for (AINodeIt it=m_Nodes.begin(); it!=m_Nodes.end(); it++){
SAINode& N = **it;
Fvector P1,P2,P3,P4,P,REF;
int c;
if (N.flags.is(SAINode::flSelected)){
sm_nodes++;
// smooth point LF
{
bool bCorner = false;
c=1; N.PointLF(REF,m_Params.fPatchSize); P1.set(REF);
if (N.nLeft()) {
SAINode& L = *N.nLeft();
L.PointFR(P,m_Params.fPatchSize); merge(P1);
if (L.nForward()) {
bCorner = true;
SAINode& C = *L.nForward();
C.PointRB(P,m_Params.fPatchSize); merge(P1);
}
}
if (N.nForward()) {
SAINode& F = *N.nForward();
F.PointBL(P,m_Params.fPatchSize); merge(P1);
if ((!bCorner) && F.nLeft()) {
bCorner = true;
SAINode& C = *F.nLeft();
C.PointRB(P,m_Params.fPatchSize); merge(P1);
}
}
R_ASSERT(c<=4);
P1.div(float(c));
}
// smooth point FR
{
bool bCorner = false;
c=1; N.PointFR(REF,m_Params.fPatchSize); P2.set(REF);
if (N.nForward()) {
SAINode& F = *N.nForward();
F.PointRB(P,m_Params.fPatchSize); merge(P2);
if (F.nRight()) {
bCorner = true;
SAINode& C = *F.nRight();
C.PointBL(P,m_Params.fPatchSize); merge(P2);
}
}
if (N.nRight()) {
SAINode& R = *N.nRight();
R.PointLF(P,m_Params.fPatchSize); merge(P2);
if ((!bCorner) && R.nForward()) {
bCorner = true;
SAINode& C = *R.nForward();
C.PointBL(P,m_Params.fPatchSize); merge(P2);
}
}
R_ASSERT(c<=4);
P2.div(float(c));
}
// smooth point RB
{
bool bCorner = false;
c=1; N.PointRB(REF,m_Params.fPatchSize); P3.set(REF);
if (N.nRight()) {
SAINode& R = *N.nRight();
R.PointBL(P,m_Params.fPatchSize); merge(P3);
if (R.nBack()) {
bCorner = true;
SAINode& C = *R.nBack();
C.PointLF(P,m_Params.fPatchSize); merge(P3);
}
}
if (N.nBack()) {
SAINode& B = *N.nBack();
B.PointFR(P,m_Params.fPatchSize); merge(P3);
if ((!bCorner) && B.nRight()) {
bCorner = true;
SAINode& C = *B.nRight();
C.PointLF(P,m_Params.fPatchSize); merge(P3);
}
}
R_ASSERT(c<=4);
P3.div(float(c));
}
// smooth point BL
{
bool bCorner = false;
c=1; N.PointBL(REF,m_Params.fPatchSize); P4.set(REF);
if (N.nBack()) {
SAINode& B = *N.nBack();
B.PointLF(P,m_Params.fPatchSize); merge(P4);
if (B.nLeft()) {
bCorner = true;
SAINode& C = *B.nLeft();
C.PointFR(P,m_Params.fPatchSize); merge(P4);
}
}
if (N.nLeft()) {
SAINode& L = *N.nLeft();
L.PointRB(P,m_Params.fPatchSize); merge(P4);
if ((!bCorner) && L.nBack()) {
bCorner = true;
SAINode& C = *L.nBack();
C.PointFR(P,m_Params.fPatchSize); merge(P4);
}
}
R_ASSERT(c<=4);
P4.div(float(c));
}
// align plane
Fvector data[4]; data[0]=P1; data[1]=P2; data[2]=P3; data[3]=P4;
Fvector vOffs,vNorm,D;
vNorm.set(N.Plane.n);
vOffs.set(N.Pos);
Mgc::OrthogonalPlaneFit(
4,(Mgc::Vector3*)data,
*((Mgc::Vector3*)&vOffs),
*((Mgc::Vector3*)&vNorm)
);
if (vNorm.y<0) vNorm.invert();
// create _new node
SAINode* NEW = xr_new<SAINode>(N);
NEW->n1 = (SAINode*)(N.n1?N.n1->idx:InvalidNode);
NEW->n2 = (SAINode*)(N.n2?N.n2->idx:InvalidNode);
NEW->n3 = (SAINode*)(N.n3?N.n3->idx:InvalidNode);
NEW->n4 = (SAINode*)(N.n4?N.n4->idx:InvalidNode);
NEW->Plane.build(vOffs,vNorm);
D.set (0,1,0);
N.Plane.intersectRayPoint(N.Pos,D,NEW->Pos); // "project" position
smoothed.push_back (NEW);
}else{
// create _new node
SAINode* NEW = xr_new<SAINode>(N);
NEW->n1 = (SAINode*)(N.n1?N.n1->idx:InvalidNode);
NEW->n2 = (SAINode*)(N.n2?N.n2->idx:InvalidNode);
NEW->n3 = (SAINode*)(N.n3?N.n3->idx:InvalidNode);
NEW->n4 = (SAINode*)(N.n4?N.n4->idx:InvalidNode);
smoothed.push_back (NEW);
}
int k = it-m_Nodes.begin();
if (k%128==0) {
pb->Update(k);
if (UI->NeedAbort()) break;
}
}
UI->ProgressEnd(pb);
Clear (true);
m_Nodes = smoothed;
DenumerateNodes ();
hash_FillFromNodes ();
UpdateHLSelected ();
if (sm_nodes) Scene->UndoSave();
}
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 ();
}
void xrMU_Reference::export_ogf()
{
xr_vector<u32> generated_ids;
// Export nodes
{
for (xrMU_Model::v_subdivs_it it=model->m_subdivs.begin(); it!=model->m_subdivs.end(); it++)
{
OGF_Reference* pOGF = xr_new<OGF_Reference> ();
b_material* M = &(pBuild->materials[it->material]); // and it's material
R_ASSERT (M);
// Common data
pOGF->Sector = sector;
pOGF->material = it->material;
// Collect textures
OGF_Texture T;
TRY(T.name = pBuild->textures[M->surfidx].name);
TRY(T.pSurface = &(pBuild->textures[M->surfidx]));
TRY(pOGF->textures.push_back(T));
// Special
pOGF->model = it->ogf;
pOGF->vb_id = it->vb_id;
pOGF->vb_start = it->vb_start;
pOGF->ib_id = it->ib_id;
pOGF->ib_start = it->ib_start;
pOGF->xform.set (xform);
pOGF->c_scale = c_scale;
pOGF->c_bias = c_bias;
pOGF->sw_id = it->sw_id;
pOGF->CalcBounds ();
generated_ids.push_back ((u32)g_tree.size());
g_tree.push_back (pOGF);
}
}
// Now, let's f**k with LODs
if (u16(-1) == model->m_lod_ID) return;
{
// Create Node and fill it with information
b_lod& LOD = pBuild->lods [model->m_lod_ID];
OGF_LOD* pNode = xr_new<OGF_LOD> (1,sector);
pNode->lod_Material = LOD.dwMaterial;
for (int lf=0; lf<8; lf++)
{
b_lod_face& F = LOD.faces[lf];
OGF_LOD::_face& D = pNode->lod_faces[lf];
for (int lv=0; lv<4; lv++)
{
xform.transform_tiny(D.v[lv].v,F.v[lv]);
D.v[lv].t = F.t[lv];
D.v[lv].c_rgb_hemi = 0xffffffff;
D.v[lv].c_sun = 0xff;
}
}
// Add all 'OGFs' with such LOD-id
for (u32 o=0; o<generated_ids.size(); o++)
pNode->AddChield(generated_ids[o]);
// Register node
R_ASSERT (pNode->chields.size());
pNode->CalcBounds ();
g_tree.push_back (pNode);
// Calculate colors
const float sm_range = 5.f;
for (int lf=0; lf<8; lf++)
{
OGF_LOD::_face& F = pNode->lod_faces[lf];
for (int lv=0; lv<4; lv++)
{
Fvector ptPos = F.v[lv].v;
base_color_c _C;
float _N = 0;
for (u32 v_it=0; v_it<model->m_vertices.size(); v_it++)
{
// get base
Fvector baseP; xform.transform_tiny (baseP,model->m_vertices[v_it]->P);
base_color_c baseC; color[v_it]._get(baseC);
base_color_c vC;
float oD = ptPos.distance_to (baseP);
float oA = 1/(1+100*oD*oD);
vC = (baseC);
vC.mul (oA);
_C.add (vC);
_N += oA;
}
float s = 1/(_N+EPS);
_C.mul (s);
F.v[lv].c_rgb_hemi = color_rgba(u8_clr(_C.rgb.x),u8_clr(_C.rgb.y),u8_clr(_C.rgb.z),u8_clr(_C.hemi));
F.v[lv].c_sun = u8_clr (_C.sun);
}
}
}
}
void CStepManager::reload(LPCSTR section)
{
m_legs_count = pSettings->r_u8 (section, "LegsCount");
LPCSTR anim_section = pSettings->r_string (section, "step_params");
if (!pSettings->section_exist(anim_section))
{
#ifdef DEBUG
Msg( "! no step_params section for :%s section :s", m_object->cName().c_str(), section );
#endif
return;
}
VERIFY((m_legs_count>=MIN_LEGS_COUNT) && (m_legs_count<=MAX_LEGS_COUNT));
SStepParam param;
param.step[0].time = 0.1f; // avoid warning
LPCSTR anim_name, val;
string16 cur_elem;
IKinematicsAnimated *skeleton_animated = smart_cast<IKinematicsAnimated*>(m_object->Visual());
VERIFY3(skeleton_animated, "object is not animated", m_object->cNameVisual().c_str());
#ifdef DEBUG
if( debug_step_info_load )
Msg( "loading step_params for object :%s, visual: %s, section: %s, step_params section: %s ", m_object->cName().c_str(), m_object->cNameVisual().c_str(), section, anim_section );
#endif
for (u32 i=0; pSettings->r_line(anim_section,i,&anim_name,&val); ++i) {
_GetItem (val,0,cur_elem);
param.cycles = u8(atoi(cur_elem));
R_ASSERT(param.cycles >= 1);
for (u32 j=0;j<m_legs_count;j++) {
_GetItem (val,1+j*2, cur_elem); param.step[j].time = float(atof(cur_elem));
_GetItem (val,1+j*2+1, cur_elem); param.step[j].power = float(atof(cur_elem));
VERIFY (_valid(param.step[j].power));
}
MotionID motion_id = skeleton_animated->ID_Cycle_Safe(anim_name);
if (!motion_id)
{
#ifdef DEBUG
IKinematicsAnimated *KA = smart_cast<IKinematicsAnimated*>(m_object->Visual());
VERIFY( KA );
Msg( "! (CStepManager::reload) no anim :%s object:%s, visual: %s, step_params section: %s ", anim_name, m_object->cName().c_str(), m_object->cNameVisual().c_str(), anim_section );
#endif
continue;
}
#ifdef DEBUG
if( debug_step_info_load )
{
IKinematicsAnimated *KA = smart_cast<IKinematicsAnimated*>(m_object->Visual());
VERIFY( KA );
std::pair<LPCSTR,LPCSTR> anim_name = KA->LL_MotionDefName_dbg( motion_id );
Msg( "step_params loaded for object :%s, visual: %s, motion: %s, anim set: %s ", m_object->cName().c_str(), m_object->cNameVisual().c_str(), anim_name.first, anim_name.second );
}
#endif
m_steps_map.insert(mk_pair(motion_id, param));
}
#ifdef DEBUG
if( m_steps_map.empty() )
Msg( "! no steps info loaded for :%s, section :s, step_params section: %s ", m_object->cName().c_str(), section, anim_section );
#endif
// reload foot bones
for (u32 i = 0; i < MAX_LEGS_COUNT; i++) m_foot_bones[i] = BI_NONE;
reload_foot_bones ();
m_time_anim_started = 0;
m_blend = 0;
}
Shader* CResourceManager::_cpp_Create (IBlender* B, LPCSTR s_shader, LPCSTR s_textures, LPCSTR s_constants, LPCSTR s_matrices)
{
CBlender_Compile C;
Shader S;
//.
// if (strstr(s_shader,"transparent")) __asm int 3;
// Access to template
C.BT = B;
C.bEditor = FALSE;
C.bDetail = FALSE;
#ifdef _EDITOR
if (!C.BT) { ELog.Msg(mtError,"Can't find shader '%s'",s_shader); return 0; }
C.bEditor = TRUE;
#endif
// Parse names
_ParseList (C.L_textures, s_textures );
_ParseList (C.L_constants, s_constants );
_ParseList (C.L_matrices, s_matrices );
// Compile element (LOD0 - HQ)
{
C.iElement = 0;
#if defined(DEBUG) && _SECURE_SCL
#pragma message("alpet: вылету здесь удивляться не стоит")
R_ASSERT(C.L_textures._Myfirst);
R_ASSERT(C.L_textures._Myproxy);
#endif
C.bDetail = m_textures_description.GetDetailTexture(C.L_textures[0],C.detail_texture,C.detail_scaler);
//. C.bDetail = _GetDetailTexture(*C.L_textures[0],C.detail_texture,C.detail_scaler);
ShaderElement E;
C._cpp_Compile (&E);
S.E[0] = _CreateElement (E);
}
// Compile element (LOD1)
{
C.iElement = 1;
//. C.bDetail = _GetDetailTexture(*C.L_textures[0],C.detail_texture,C.detail_scaler);
C.bDetail = m_textures_description.GetDetailTexture(C.L_textures[0],C.detail_texture,C.detail_scaler);
ShaderElement E;
C._cpp_Compile (&E);
S.E[1] = _CreateElement (E);
}
// Compile element
{
C.iElement = 2;
C.bDetail = FALSE;
ShaderElement E;
C._cpp_Compile (&E);
S.E[2] = _CreateElement (E);
}
// Compile element
{
C.iElement = 3;
C.bDetail = FALSE;
ShaderElement E;
C._cpp_Compile (&E);
S.E[3] = _CreateElement (E);
}
// Compile element
{
C.iElement = 4;
C.bDetail = TRUE; //.$$$ HACK :)
ShaderElement E;
C._cpp_Compile (&E);
S.E[4] = _CreateElement (E);
}
// Compile element
{
C.iElement = 5;
C.bDetail = FALSE;
ShaderElement E;
C._cpp_Compile (&E);
S.E[5] = _CreateElement (E);
}
// Search equal in shaders array
for (u32 it=0; it<v_shaders.size(); it++)
if (S.equal(v_shaders[it])) return v_shaders[it];
// Create _new_ entry
Shader* N = xr_new<Shader>(S);
N->dwFlags |= xr_resource_flagged::RF_REGISTERED;
v_shaders.push_back (N);
return N;
}
void CUIStatsWnd::SelectItem(const u32 uItem)
{
R_ASSERT(static_cast<int>(uItem) < UIStatsList.GetItemsCount());
UIStatsList.SetFocusedItem(static_cast<signed int>(uItem));
}
u32 attachable_hud_item::anim_play(const shared_str& anm_name_b, BOOL bMixIn, const CMotionDef*& md, u8& rnd_idx)
{
float speed = CalcMotionSpeed(anm_name_b);
R_ASSERT (strstr(anm_name_b.c_str(),"anm_")==anm_name_b.c_str());
string256 anim_name_r;
bool is_16x9 = UI().is_widescreen();
xr_sprintf (anim_name_r,"%s%s",anm_name_b.c_str(),((m_attach_place_idx==1)&&is_16x9)?"_16x9":"");
player_hud_motion* anm = m_hand_motions.find_motion(anim_name_r);
R_ASSERT2 (anm, make_string("model [%s] has no motion alias defined [%s]", m_sect_name.c_str(), anim_name_r).c_str());
R_ASSERT2 (anm->m_animations.size(), make_string("model [%s] has no motion defined in motion_alias [%s]", pSettings->r_string(m_sect_name, "item_visual"), anim_name_r).c_str());
rnd_idx = (u8)Random.randI(anm->m_animations.size()) ;
const motion_descr& M = anm->m_animations[ rnd_idx ];
u32 ret = g_player_hud->anim_play(m_attach_place_idx, M.mid, bMixIn, md, speed);
if(m_model->dcast_PKinematicsAnimated())
{
IKinematicsAnimated* ka = m_model->dcast_PKinematicsAnimated();
shared_str item_anm_name;
if(anm->m_base_name!=anm->m_additional_name)
item_anm_name = anm->m_additional_name;
else
item_anm_name = M.name;
MotionID M2 = ka->ID_Cycle_Safe(item_anm_name);
if(!M2.valid())
M2 = ka->ID_Cycle_Safe("idle");
else
if(bDebug)
Msg ("playing item animation [%s]",item_anm_name.c_str());
R_ASSERT3(M2.valid(),"model has no motion [idle] ", pSettings->r_string(m_sect_name, "item_visual"));
u16 root_id = m_model->LL_GetBoneRoot();
CBoneInstance& root_binst = m_model->LL_GetBoneInstance(root_id);
root_binst.set_callback_overwrite(TRUE);
root_binst.mTransform.identity ();
u16 pc = ka->partitions().count();
for(u16 pid=0; pid<pc; ++pid)
{
CBlend* B = ka->PlayCycle(pid, M2, bMixIn);
R_ASSERT (B);
B->speed *= speed;
}
m_model->CalculateBones_Invalidate ();
}
R_ASSERT2 (m_parent_hud_item, "parent hud item is NULL");
CPhysicItem& parent_object = m_parent_hud_item->object();
//R_ASSERT2 (parent_object, "object has no parent actor");
//CObject* parent_object = static_cast_checked<CObject*>(&m_parent_hud_item->object());
if (IsGameTypeSingle() && parent_object.H_Parent() == Level().CurrentControlEntity())
{
CActor* current_actor = static_cast_checked<CActor*>(Level().CurrentControlEntity());
VERIFY (current_actor);
CEffectorCam* ec = current_actor->Cameras().GetCamEffector(eCEWeaponAction);
if(NULL==ec)
{
string_path ce_path;
string_path anm_name;
strconcat (sizeof(anm_name),anm_name,"camera_effects\\weapon\\", M.name.c_str(),".anm");
if (FS.exist( ce_path, "$game_anims$", anm_name))
{
CAnimatorCamEffector* e = xr_new<CAnimatorCamEffector>();
e->SetType (eCEWeaponAction);
e->SetHudAffect (false);
e->SetCyclic (false);
e->Start (anm_name);
current_actor->Cameras().AddCamEffector(e);
}
}
}
return ret;
}
void CUIStatsListItem::SetSubItemColor(u32 uItemIndex, u32 uColor)
{
R_ASSERT(uItemIndex < FieldsVector.size());
FieldsVector[uItemIndex]->SetTextColor(uColor);
}
void SAINode::LoadLTX(CInifile& ini, LPCSTR sect_name, ESceneAIMapTool* tools)
{
R_ASSERT(0);
}
void xrServer::Process_event (NET_Packet& P, ClientID sender)
{
# ifdef SLOW_VERIFY_ENTITIES
VERIFY (verify_entities());
# endif
u32 timestamp;
u16 type;
u16 destination;
u32 MODE = net_flags(TRUE,TRUE);
// correct timestamp with server-unique-time (note: direct message correction)
P.r_u32 (timestamp );
// read generic info
P.r_u16 (type );
P.r_u16 (destination);
CSE_Abstract* receiver = game->get_entity_from_eid (destination);
if (receiver)
{
R_ASSERT(receiver->owner);
receiver->OnEvent (P,type,timestamp,sender);
};
switch (type)
{
case GE_GAME_EVENT:
{
u16 game_event_type;
P.r_u16(game_event_type);
game->AddDelayedEvent(P,game_event_type,timestamp,sender);
}break;
case GE_INFO_TRANSFER:
case GE_WPN_STATE_CHANGE:
case GE_ZONE_STATE_CHANGE:
case GE_ACTOR_JUMPING:
case GEG_PLAYER_PLAY_HEADSHOT_PARTICLE:
case GEG_PLAYER_ATTACH_HOLDER:
case GEG_PLAYER_DETACH_HOLDER:
case GEG_PLAYER_ITEM2SLOT:
case GEG_PLAYER_ITEM2BELT:
case GEG_PLAYER_ITEM2RUCK:
case GE_GRENADE_EXPLODE:
{
SendBroadcast (BroadcastCID,P,MODE);
}break;
case GEG_PLAYER_ACTIVATEARTEFACT:
{
Process_event_activate (P,sender,timestamp,destination,P.r_u16(), true);
break;
};
case GE_INV_ACTION:
{
xrClientData* CL = ID_to_client(sender);
if (CL) CL->net_Ready = TRUE;
if (SV_Client) SendTo(SV_Client->ID, P, net_flags(TRUE, TRUE));
}break;
case GE_RESPAWN:
{
CSE_Abstract* E = receiver;
if (E)
{
R_ASSERT (E->s_flags.is(M_SPAWN_OBJECT_PHANTOM));
svs_respawn R;
R.timestamp = timestamp + E->RespawnTime*1000;
R.phantom = destination;
q_respawn.insert (R);
}
}
break;
case GE_TRADE_BUY:
case GE_OWNERSHIP_TAKE:
{
Process_event_ownership (P,sender,timestamp,destination);
VERIFY (verify_entities());
}break;
case GE_OWNERSHIP_TAKE_MP_FORCED:
{
Process_event_ownership (P,sender,timestamp,destination,TRUE);
VERIFY (verify_entities());
}break;
case GE_TRADE_SELL:
case GE_OWNERSHIP_REJECT:
case GE_LAUNCH_ROCKET:
{
Process_event_reject (P,sender,timestamp,destination,P.r_u16());
VERIFY (verify_entities());
}break;
case GE_DESTROY:
{
Process_event_destroy (P,sender,timestamp,destination, NULL);
VERIFY (verify_entities());
}
break;
case GE_TRANSFER_AMMO:
{
u16 id_entity;
P.r_u16 (id_entity);
CSE_Abstract* e_parent = receiver; // кто забирает (для своих нужд)
CSE_Abstract* e_entity = game->get_entity_from_eid (id_entity); // кто отдает
if (!e_entity) break;
if (0xffff != e_entity->ID_Parent) break; // this item already taken
xrClientData* c_parent = e_parent->owner;
xrClientData* c_from = ID_to_client (sender);
R_ASSERT (c_from == c_parent); // assure client ownership of event
// Signal to everyone (including sender)
SendBroadcast (BroadcastCID,P,MODE);
// Perfrom real destroy
entity_Destroy (e_entity );
VERIFY (verify_entities());
}
break;
case GE_HIT:
case GE_HIT_STATISTIC:
{
P.r_pos -=2;
if (type == GE_HIT_STATISTIC)
{
P.B.count -= 4;
P.w_u32(sender.value());
};
game->AddDelayedEvent(P,GAME_EVENT_ON_HIT, 0, ClientID() );
} break;
case GE_ASSIGN_KILLER: {
u16 id_src;
P.r_u16 (id_src);
CSE_Abstract *e_dest = receiver; // кто умер
// this is possible when hit event is sent before destroy event
if (!e_dest)
break;
CSE_ALifeCreatureAbstract *creature = smart_cast<CSE_ALifeCreatureAbstract*>(e_dest);
if (creature)
creature->set_killer_id( id_src );
// Msg ("[%d][%s] killed [%d][%s]",id_src,id_src==u16(-1) ? "UNKNOWN" : game->get_entity_from_eid(id_src)->name_replace(),id_dest,e_dest->name_replace());
break;
}
case GE_CHANGE_VISUAL:
{
CSE_Visual* visual = smart_cast<CSE_Visual*>(receiver); VERIFY(visual);
string256 tmp;
P.r_stringZ (tmp);
visual->set_visual (tmp);
}break;
case GE_DIE:
{
// Parse message
u16 id_dest = destination, id_src;
P.r_u16 (id_src);
xrClientData *l_pC = ID_to_client(sender);
VERIFY (game && l_pC);
#ifndef MASTER_GOLD
if ((game->Type() != eGameIDSingle) && l_pC && l_pC->owner)
{
Msg ("* [%2d] killed by [%2d] - sended by [%s:%2d]", id_dest, id_src, game->get_option_s(*l_pC->name,"name","Player"), l_pC->owner->ID);
}
#endif // #ifndef MASTER_GOLD
CSE_Abstract* e_dest = receiver; // кто умер
// this is possible when hit event is sent before destroy event
if (!e_dest)
break;
#ifndef MASTER_GOLD
if (game->Type() != eGameIDSingle)
Msg ("* [%2d] is [%s:%s]", id_dest, *e_dest->s_name, e_dest->name_replace());
#endif // #ifndef MASTER_GOLD
CSE_Abstract* e_src = game->get_entity_from_eid (id_src ); // кто убил
if (!e_src) {
xrClientData* C = (xrClientData*) game->get_client(id_src);
if (C) e_src = C->owner;
};
VERIFY (e_src);
if (!e_src)
{
Msg("! ERROR: SV: src killer not exist.");
return;
}
// R_ASSERT2 (e_dest && e_src, "Killer or/and being killed are offline or not exist at all :(");
#ifndef MASTER_GOLD
if (game->Type() != eGameIDSingle)
Msg ("* [%2d] is [%s:%s]", id_src, *e_src->s_name, e_src->name_replace());
#endif // #ifndef MASTER_GOLD
game->on_death (e_dest,e_src);
xrClientData* c_src = e_src->owner; // клиент, чей юнит убил
if (c_src->owner->ID == id_src) {
// Main unit
P.w_begin (M_EVENT);
P.w_u32 (timestamp);
P.w_u16 (type);
P.w_u16 (destination);
P.w_u16 (id_src);
P.w_clientID (c_src->ID);
}
SendBroadcast (BroadcastCID,P,MODE);
//////////////////////////////////////////////////////////////////////////
//
if (game->Type() == eGameIDSingle) {
P.w_begin (M_EVENT);
P.w_u32 (timestamp);
P.w_u16 (GE_KILL_SOMEONE);
P.w_u16 (id_src);
P.w_u16 (destination);
SendTo (c_src->ID, P, net_flags(TRUE, TRUE));
}
//////////////////////////////////////////////////////////////////////////
VERIFY (verify_entities());
}
break;
case GE_ADDON_ATTACH:
case GE_ADDON_DETACH:
case GE_CHANGE_POS:
{
SendTo(SV_Client->ID, P, net_flags(TRUE, TRUE));
}break;
case GE_INSTALL_UPGRADE:
{
shared_str upgrade_id;
P.r_stringZ ( upgrade_id );
CSE_ALifeInventoryItem* iitem = smart_cast<CSE_ALifeInventoryItem*>( receiver );
if ( !iitem )
{
break;
}
iitem->add_upgrade ( upgrade_id );
}break;
case GEG_PLAYER_DISABLE_SPRINT:
case GEG_PLAYER_WEAPON_HIDE_STATE:
{
SendTo (SV_Client->ID, P, net_flags(TRUE, TRUE));
# ifdef SLOW_VERIFY_ENTITIES
VERIFY (verify_entities());
# endif
}break;
case GEG_PLAYER_ACTIVATE_SLOT:
case GEG_PLAYER_ITEM_EAT:
{
SendTo(SV_Client->ID, P, net_flags(TRUE, TRUE));
# ifdef SLOW_VERIFY_ENTITIES
VERIFY (verify_entities());
# endif
}break;
case GEG_PLAYER_ITEM_SELL:
{
game->OnPlayer_Sell_Item(sender, P);
}break;
case GE_TELEPORT_OBJECT:
{
game->teleport_object (P,destination);
}break;
case GE_ADD_RESTRICTION:
{
game->add_restriction (P,destination);
}break;
case GE_REMOVE_RESTRICTION:
{
game->remove_restriction(P,destination);
}break;
case GE_REMOVE_ALL_RESTRICTIONS:
{
game->remove_all_restrictions(P,destination);
}break;
case GE_MONEY:
{
CSE_Abstract *e_dest = receiver;
CSE_ALifeTraderAbstract* pTa = smart_cast<CSE_ALifeTraderAbstract*>(e_dest);
pTa->m_dwMoney = P.r_u32();
}break;
case GE_FREEZE_OBJECT:
break;
default:
R_ASSERT2 (0,"Game Event not implemented!!!");
break;
}
}
void CBuild::BuildSectors()
{
Status("Determining sectors...");
Progress(0);
u32 SectorMax=0;
for (u32 I=0; I<g_tree.size(); I++)
if (g_tree[I]->Sector>SectorMax) SectorMax=g_tree[I]->Sector;
R_ASSERT(SectorMax<0xffff);
u32 SectorCount = SectorMax+1;
g_sectors.resize(SectorCount);
ZeroMemory(&*g_sectors.begin(),(u32)g_sectors.size()*sizeof(void*));
clMsg("%d sectors accepted.",SectorCount);
Status("Spatializing geometry...");
for (u32 I=0; I<g_tree.size(); I++)
{
u32 Sector = g_tree[I]->Sector;
if (0==g_sectors[Sector]) g_sectors[Sector] = xr_new<CSector> (Sector);
}
Status("Building hierrarhy...");
for (u32 I=0; I<g_sectors.size(); I++)
{
R_ASSERT(g_sectors[I]);
g_sectors[I]->BuildHierrarhy();
Progress(float(I)/float(g_sectors.size()));
}
Status("Assigning portals, occluders, glows, lights...");
// portals
for (u32 I=0; I<portals.size(); I++)
{
b_portal &P = portals[I];
R_ASSERT(u32(P.sector_front)<g_sectors.size());
R_ASSERT(u32(P.sector_back) <g_sectors.size());
g_sectors[u32(P.sector_front)]->add_portal (u16(I));
g_sectors[u32(P.sector_back)]->add_portal (u16(I));
}
// glows
for (u32 I=0; I<glows.size(); I++)
{
b_glow &G = glows[I];
b_material &M = materials[G.dwMaterial];
R_ASSERT(M.sector<g_sectors.size());
g_sectors[M.sector]->add_glow (u16(I));
}
// lights
for (u32 I=0; I<L_dynamic.size(); I++)
{
b_light_dynamic &L = L_dynamic[I];
if (L.data.type == D3DLIGHT_DIRECTIONAL)
{
for (u32 j=0; j<g_sectors.size(); j++)
{
R_ASSERT(g_sectors[j]);
g_sectors[j]->add_light(u16(I));
}
} else {
if (L.sectors.size()) {
for (u32 j=0; j<L.sectors.size(); j++)
{
R_ASSERT (L.sectors[j]<g_sectors.size());
g_sectors [L.sectors[j]]->add_light(u16(I));
}
} else {
clMsg("F**k!!! Light at position %f,%f,%f non associated!!!",
L.data.position.x,L.data.position.y,L.data.position.z
);
}
}
}
}
bool ESceneObjectTool::ExportBreakableObjects(SExportStreams* F)
{
bool bResult = true;
CGeomPartExtractor* extractor=0;
Fbox bb;
if (!GetBox(bb)) return false;
extractor = xr_new<CGeomPartExtractor>();
extractor->Initialize(bb,EPS_L,2);
UI->SetStatus ("Export breakable objects...");
// collect verts&&faces
{
SPBItem* pb = UI->ProgressStart(m_Objects.size(),"Prepare geometry...");
for (ObjectIt it=m_Objects.begin(); it!=m_Objects.end(); it++){
pb->Inc();
CSceneObject* obj = dynamic_cast<CSceneObject*>(*it); VERIFY(obj);
if (obj->IsStatic()){
CEditableObject *O = obj->GetReference();
const Fmatrix& T = obj->_Transform();
for(EditMeshIt M=O->FirstMesh();M!=O->LastMesh();M++)
if (!build_mesh (T,*M,extractor,SGameMtl::flBreakable,FALSE)){bResult=false;break;}
}
}
UI->ProgressEnd(pb);
}
if (!extractor->Process()) bResult = false;
// export parts
if (bResult){
SBPartVec& parts = extractor->GetParts();
SPBItem* pb = UI->ProgressStart(parts.size(),"Export Parts...");
for (SBPartVecIt p_it=parts.begin(); p_it!=parts.end(); p_it++){
pb->Inc();
SBPart* P = *p_it;
if (P->Valid()){
// export visual
AnsiString sn = AnsiString().sprintf("meshes\\brkbl#%d.ogf",(p_it-parts.begin()));
xr_string fn = Scene->LevelPath()+sn.c_str();
IWriter* W = FS.w_open(fn.c_str()); R_ASSERT(W);
if (!P->Export(*W,1)){
ELog.DlgMsg (mtError,"Invalid breakable object.");
bResult = false;
break;
}
FS.w_close (W);
// export spawn object
{
AnsiString entity_ref = "breakable_object";
ISE_Abstract* m_Data = create_entity(entity_ref.c_str()); VERIFY(m_Data);
CSE_Visual* m_Visual = m_Data->visual(); VERIFY(m_Visual);
// set params
m_Data->set_name (entity_ref.c_str());
m_Data->set_name_replace (sn.c_str());
m_Data->position().set (P->m_RefOffset);
m_Data->angle().set (P->m_RefRotate);
m_Visual->set_visual (sn.c_str(),false);
if (s_draw_dbg){
Fmatrix MX;
MX.setXYZi (P->m_RefRotate);
MX.translate_over (P->m_RefOffset);
Fvector DR = {0,0,1};
MX.transform_dir (DR);
Tools->m_DebugDraw.AppendLine(P->m_RefOffset,Fvector().mad(P->m_RefOffset,MX.k,1.f),0xFF0000FF,false,false);
}
NET_Packet Packet;
m_Data->Spawn_Write (Packet,TRUE);
F->spawn.stream.open_chunk (F->spawn.chunk++);
F->spawn.stream.w (Packet.B.data,Packet.B.count);
F->spawn.stream.close_chunk ();
destroy_entity (m_Data);
}
}else{
ELog.Msg(mtError,"Can't export invalid part #%d",p_it-parts.begin());
}
}
UI->ProgressEnd(pb);
}
// clean up
xr_delete(extractor);
return bResult;
}
void CKinematicsAnimated::Load(const char* N, IReader *data, u32 dwFlags)
{
inherited::Load (N, data, dwFlags);
// Globals
blend_instances = NULL;
m_Partition = NULL;
Update_LastTime = 0;
// Load animation
if (data->find_chunk(OGF_S_MOTION_REFS)){
string_path items_nm;
data->r_stringZ (items_nm,sizeof(items_nm));
u32 set_cnt = _GetItemCount(items_nm);
R_ASSERT (set_cnt<MAX_ANIM_SLOT);
m_Motions.reserve(set_cnt);
string_path nm;
for (u32 k=0; k<set_cnt; k++){
_GetItem (items_nm,k,nm);
strcat (nm,".omf");
string_path fn;
if (!FS.exist(fn, "$level$", nm)){
if (!FS.exist(fn, "$game_meshes$", nm)){
#ifdef _EDITOR
Msg ("!Can't find motion file '%s'.",nm);
return;
#else
Debug.fatal (DEBUG_INFO,"Can't find motion file '%s'.",nm);
#endif
}
}
// Check compatibility
m_Motions.push_back (SMotionsSlot());
if( !g_pMotionsContainer->has(nm) ) //optimize fs operations
{
IReader* MS = FS.r_open(fn);
m_Motions.back().motions.create (nm,MS,bones);
FS.r_close (MS);
}
m_Motions.back().motions.create (nm,NULL,bones);
}
}else{
string_path nm;
strconcat (sizeof(nm),nm,N,".ogf");
m_Motions.push_back(SMotionsSlot());
m_Motions.back().motions.create(nm,data,bones);
}
R_ASSERT (m_Motions.size());
m_Partition = m_Motions[0].motions.partition();
// initialize motions
for (MotionsSlotVecIt m_it=m_Motions.begin(); m_it!=m_Motions.end(); m_it++){
SMotionsSlot& MS = *m_it;
MS.bone_motions.resize(bones->size());
for (u32 i=0; i<bones->size(); i++){
CBoneData* BD = (*bones)[i];
MS.bone_motions[i] = MS.motions.bone_motions(BD->name);
}
}
// Init blend pool
IBlend_Startup ();
//. if (motions.cycle()->size()<2)
//. Msg("* WARNING: model '%s' has only one motion. Candidate for SkeletonRigid???",N);
}
void Startup(LPSTR lpCmdLine)
{
char cmd[512],name[256];
BOOL bModifyOptions = FALSE;
strcpy(cmd,lpCmdLine);
strlwr(cmd);
if (strstr(cmd,"-?") || strstr(cmd,"-h")) { Help(); return; }
if (strstr(cmd,"-f")==0) { Help(); return; }
if (strstr(cmd,"-o")) bModifyOptions = TRUE;
if (strstr(cmd,"-gi")) b_radiosity = TRUE;
if (strstr(cmd,"-noise")) b_noise = TRUE;
if (strstr(cmd,"-nosun")) b_nosun = TRUE;
// Give a LOG-thread a chance to startup
//_set_sbh_threshold(1920);
InitCommonControls ();
thread_spawn (logThread, "log-update", 1024*1024,0);
Sleep (150);
// Faster FPU
SetPriorityClass (GetCurrentProcess(),NORMAL_PRIORITY_CLASS);
/*
u32 dwMin = 1800*(1024*1024);
u32 dwMax = 1900*(1024*1024);
if (0==SetProcessWorkingSetSize(GetCurrentProcess(),dwMin,dwMax))
{
clMsg("*** Failed to expand working set");
};
*/
// Load project
name[0]=0; sscanf(strstr(cmd,"-f")+2,"%s",name);
string256 prjName;
FS.update_path (prjName,"$game_levels$",strconcat(prjName,name,"\\build.prj"));
string256 phaseName;
Phase (strconcat(phaseName,"Reading project [",name,"]..."));
string256 inf;
extern HWND logWindow;
IReader* F = FS.r_open(prjName);
if (NULL==F){
sprintf (inf,"Build failed!\nCan't find level: '%s'",name);
clMsg (inf);
MessageBox (logWindow,inf,"Error!",MB_OK|MB_ICONERROR);
return;
}
// Version
u32 version;
F->r_chunk (EB_Version,&version);
clMsg ("version: %d",version);
R_ASSERT(XRCL_CURRENT_VERSION==version);
// Header
b_params Params;
F->r_chunk (EB_Parameters,&Params);
// Show options if needed
if (bModifyOptions)
{
Phase ("Project options...");
HMODULE L = LoadLibrary ("xrLC_Options.dll");
void* P = GetProcAddress (L,"_frmScenePropertiesRun");
R_ASSERT (P);
xrOptions* O = (xrOptions*)P;
int R = O(&Params,version,false);
FreeLibrary (L);
if (R==2) {
ExitProcess(0);
}
}
// Conversion
Phase ("Converting data structures...");
pBuild = xr_new<CBuild>();
pBuild->Load (Params,*F);
xr_delete (F);
// Call for builder
string256 lfn;
CTimer dwStartupTime; dwStartupTime.Start();
FS.update_path (lfn,_game_levels_,name);
pBuild->Run (lfn);
xr_delete (pBuild);
// Show statistic
extern std::string make_time(u32 sec);
u32 dwEndTime = dwStartupTime.GetElapsed_ms();
sprintf (inf,"Time elapsed: %s",make_time(dwEndTime/1000).c_str());
clMsg ("Build succesful!\n%s",inf);
MessageBox (logWindow,inf,"Congratulation!",MB_OK|MB_ICONINFORMATION);
// Close log
bClose = TRUE;
Sleep (500);
}
void game_sv_GameState::SetPointFreezed (RPoint* rp)
{
R_ASSERT(rp);
rp->TimeToUnfreeze = Level().timeServer() + g_sv_base_dwRPointFreezeTime;
}
void xrServer::Process_event_destroy (NET_Packet& P, ClientID sender, u32 time, u16 ID, NET_Packet* pEPack)
{
u32 MODE = net_flags(TRUE,TRUE);
// Parse message
u16 id_dest = ID;
#ifdef DEBUG
if( dbg_net_Draw_Flags.test( dbg_destroy ) )
Msg ("sv destroy object %s [%d]", ent_name_safe(id_dest).c_str(), Device.dwFrame);
#endif
CSE_Abstract* e_dest = game->get_entity_from_eid (id_dest); // кто должен быть уничтожен
if (!e_dest)
{
#ifndef MASTER_GOLD
Msg ("! SV:ge_destroy: [%d] not found on server",id_dest);
#endif // #ifndef MASTER_GOLD
return;
};
R_ASSERT (e_dest);
xrClientData *c_dest = e_dest->owner; // клиент, чей юнит
R_ASSERT (c_dest);
xrClientData *c_from = ID_to_client(sender); // клиент, кто прислал
R_ASSERT (c_dest == c_from); // assure client ownership of event
u16 parent_id = e_dest->ID_Parent;
#ifdef MP_LOGGING
Msg("- SV: Process destroy: parent [%d] item [%d][%s]",
parent_id, id_dest, e_dest->name());
#endif //#ifdef MP_LOGGING
//---------------------------------------------
NET_Packet P2, *pEventPack = pEPack;
P2.w_begin (M_EVENT_PACK);
//---------------------------------------------
// check if we have children
if (!e_dest->children.empty()) {
if (!pEventPack) pEventPack = &P2;
while (!e_dest->children.empty())
Process_event_destroy (P,sender,time,*e_dest->children.begin(), pEventPack);
};
if (0xffff == parent_id && NULL == pEventPack)
{
SendBroadcast (BroadcastCID,P,MODE);
}
else
{
NET_Packet tmpP;
if (0xffff != parent_id && Process_event_reject(P,sender,time,parent_id,ID,false))
{
game->u_EventGen(tmpP, GE_OWNERSHIP_REJECT, parent_id);
tmpP.w_u16(id_dest);
tmpP.w_u8(1);
if (!pEventPack) pEventPack = &P2;
pEventPack->w_u8(u8(tmpP.B.count));
pEventPack->w(&tmpP.B.data, tmpP.B.count);
};
game->u_EventGen(tmpP, GE_DESTROY, id_dest);
pEventPack->w_u8(u8(tmpP.B.count));
pEventPack->w(&tmpP.B.data, tmpP.B.count);
};
if (NULL == pEPack && NULL != pEventPack)
{
SendBroadcast (BroadcastCID, *pEventPack, MODE);
}
// Everything OK, so perform entity-destroy
if (e_dest->m_bALifeControl && ai().get_alife()) {
game_sv_Single *_game = smart_cast<game_sv_Single*>(game);
VERIFY (_game);
if (ai().alife().objects().object(id_dest,true))
_game->alife().release (e_dest,false);
}
if (game)
game->OnDestroyObject (e_dest->ID);
entity_Destroy (e_dest);
}
void CBuild::xrPhase_UVmap()
{
// Main loop
Status ("Processing...");
g_deflectors.reserve (64*1024);
float p_cost = 1.f / float(g_XSplit.size());
float p_total = 0.f;
vecFace faces_affected;
for (int SP = 0; SP<int(g_XSplit.size()); SP++)
{
Progress (p_total+=p_cost);
IsolateVertices (FALSE);
// Detect vertex-lighting and avoid this subdivision
R_ASSERT (!g_XSplit[SP]->empty());
Face* Fvl = g_XSplit[SP]->front();
if (Fvl->Shader().flags.bLIGHT_Vertex) continue; // do-not touch (skip)
if (!Fvl->Shader().flags.bRendering) continue; // do-not touch (skip)
if (Fvl->hasImplicitLighting()) continue; // do-not touch (skip)
// find first poly that doesn't has mapping and start recursion
while (TRUE) {
// Select maximal sized poly
Face * msF = NULL;
float msA = 0;
for (vecFaceIt it = g_XSplit[SP]->begin(); it!=g_XSplit[SP]->end(); it++)
{
if ( (*it)->pDeflector == NULL ) {
float a = (*it)->CalcArea();
if (a>msA) {
msF = (*it);
msA = a;
}
}
}
if (msF) {
g_deflectors.push_back (xr_new<CDeflector>());
// Start recursion from this face
affected = 1;
Deflector->OA_SetNormal (msF->N);
msF->OA_Unwarp ();
// break the cycle to startup again
Deflector->OA_Export ();
// Detach affected faces
faces_affected.clear ();
for (int i=0; i<int(g_XSplit[SP]->size()); i++) {
Face *F = (*g_XSplit[SP])[i];
if ( F->pDeflector==Deflector ) {
faces_affected.push_back(F);
g_XSplit[SP]->erase (g_XSplit[SP]->begin()+i);
i--;
}
}
// detaching itself
Detach (&faces_affected);
g_XSplit.push_back (xr_new<vecFace> (faces_affected));
} else {
if (g_XSplit[SP]->empty())
{
xr_delete (g_XSplit[SP]);
g_XSplit.erase (g_XSplit.begin()+SP);
SP--;
}
// Cancel infine loop (while)
break;
}
}
}
clMsg("%d subdivisions...",g_XSplit.size());
}
void CBuild::Flex2OGF()
{
float p_total = 0;
float p_cost = 1/float(g_XSplit.size());
validate_splits ();
g_tree.clear ();
g_tree.reserve (4096);
for (splitIt it=g_XSplit.begin(); it!=g_XSplit.end(); it++)
{
R_ASSERT ( ! (*it)->empty() );
u32 MODEL_ID = u32(it-g_XSplit.begin());
OGF* pOGF = new OGF();
Face* F = *((*it)->begin()); // first face
b_material* M = &(materials()[F->dwMaterial]); // and it's material
R_ASSERT (F && M);
try {
// Common data
pOGF->Sector = M->sector;
pOGF->material = F->dwMaterial;
// Collect textures
OGF_Texture T;
//pOGF->shader = M->shader;
//pOGF->shader_xrlc = &F->Shader();
TRY(T.name = textures()[M->surfidx].name);
TRY(T.pSurface = &(textures()[M->surfidx]));
TRY(pOGF->textures.push_back(T));
try {
if (F->hasImplicitLighting())
{
// specific lmap
string_path tn;
strconcat (sizeof(tn),tn,*T.name,"_lm.dds");
T.name = tn;
T.pSurface = T.pSurface; // Leave surface intact
R_ASSERT (pOGF);
pOGF->textures.push_back(T);
} else {
// If lightmaps persist
CLightmap* LM = F->lmap_layer;
if (LM) {
string_path fn;
sprintf_s (fn,"%s_1",LM->lm_texture.name);
T.name = fn;
T.pSurface = &(LM->lm_texture);
R_ASSERT (T.pSurface);
R_ASSERT (pOGF);
pOGF->textures.push_back(T); //.
sprintf (fn,"%s_2",LM->lm_texture.name);
T.name = fn;
pOGF->textures.push_back(T);
}
}
} catch (...) { clMsg("* ERROR: Flex2OGF, model# %d, *textures*",MODEL_ID); }
// Collect faces & vertices
F->CacheOpacity ();
bool _tc_ = !(F->flags.bOpaque);
try {
BuildOGFGeom( *pOGF, *(*it), _tc_ );
} catch (...) { clMsg("* ERROR: Flex2OGF, model# %d, *faces*",MODEL_ID); }
} catch (...)
{
clMsg("* ERROR: Flex2OGF, 1st part, model# %d",MODEL_ID);
}
try {
clMsg ("%3d: opt : v(%d)-f(%d)", MODEL_ID,pOGF->data.vertices.size(),pOGF->data.faces.size());
pOGF->Optimize ();
clMsg ("%3d: cb : v(%d)-f(%d)", MODEL_ID,pOGF->data.vertices.size(),pOGF->data.faces.size());
pOGF->CalcBounds ();
clMsg ("%3d: prog: v(%d)-f(%d)", MODEL_ID,pOGF->data.vertices.size(),pOGF->data.faces.size());
if (!b_noise) pOGF->MakeProgressive (c_PM_MetricLimit_static);
clMsg ("%3d: strp: v(%d)-f(%d)", MODEL_ID,pOGF->data.vertices.size(),pOGF->data.faces.size());
pOGF->Stripify ();
} catch (...) {
clMsg("* ERROR: Flex2OGF, 2nd part, model# %d",MODEL_ID);
}
g_tree.push_back (pOGF);
xr_delete (*it);
Progress (p_total+=p_cost);
}
g_XSplit.clear ();
}
CUIMultiTextStatic::SinglePhrase * CUIMultiTextStatic::GetPhraseByIndex(u32 idx)
{
R_ASSERT(idx < m_vPhrases.size());
return &m_vPhrases[idx];
}
bool ESoundSource::Load(IReader& F)
{
u32 version = 0;
if(F.r_chunk(SOUND_CHUNK_VERSION,&version)){
if(version!=SOUND_SOURCE_VERSION){
ELog.Msg( mtError, "ESoundSource: Unsupported version.");
return false;
}
}else return false;
inherited::Load (F);
R_ASSERT(F.find_chunk(SOUND_CHUNK_TYPE));
m_Type = ESoundType(F.r_u32());
R_ASSERT(F.find_chunk(SOUND_CHUNK_SOURCE_NAME));
F.r_stringZ (m_WAVName);
if (F.find_chunk(SOUND_CHUNK_SOURCE_PARAMS3)){
m_Params.base_volume = 1.f;
F.r_fvector3 (m_Params.position);
m_Params.volume = F.r_float();
m_Params.freq = F.r_float();
m_Params.min_distance = F.r_float();
m_Params.max_distance = F.r_float();
m_Params.max_ai_distance= F.r_float();
}else if (F.find_chunk(SOUND_CHUNK_SOURCE_PARAMS2)){
m_Params.base_volume = 1.f;
F.r_fvector3 (m_Params.position);
m_Params.volume = F.r_float();
m_Params.freq = F.r_float();
m_Params.min_distance = F.r_float();
m_Params.max_distance = F.r_float();
m_Params.max_ai_distance= F.r_float();
}else{
if (!F.find_chunk(SOUND_CHUNK_SOURCE_PARAMS)){
ELog.DlgMsg( mtError, "ESoundSource: Can't load Sound Source '%s'. Unsupported version.",*m_WAVName);
return false;
}
m_Params.base_volume = 1.f;
F.r_fvector3 (m_Params.position);
m_Params.volume = F.r_float();
m_Params.freq = F.r_float();
m_Params.min_distance = F.r_float();
m_Params.max_distance = F.r_float();
m_Params.max_ai_distance= m_Params.max_distance;
}
if(F.find_chunk(SOUND_CHUNK_SOURCE_FLAGS))
F.r (&m_Flags,sizeof(m_Flags));
if(F.find_chunk(SOUND_CHUNK_GAME_PARAMS)){
F.r_fvector2 (m_RandomPause);
F.r_fvector2 (m_ActiveTime);
F.r_fvector2 (m_PlayTime);
}
ResetSource ();
switch (m_Type){
case stStaticSource:
if (m_Flags.is(flPlaying)) Play();
if (m_Flags.is(flSimulating)) Simulate();
break;
default: THROW;
}
return true;
}
