std::pair<u32,u32> get_id( const xr_vector<xrMU_Model*>& mu_models, const T * v )
{
u32 face_id = u32(-1);
struct find
{
const T * _v;
u32& _id;
find( const T * v, u32& id) : _v(v), _id( id )
{}
bool operator () ( const xrMU_Model * m )
{
VERIFY(m);
u32 id = m->find( _v );
if( id == u32(-1) )
return false;
_id = id;
return true;
}
} f( v, face_id );
xr_vector<xrMU_Model*> :: const_iterator ii =std::find_if( mu_models.begin(), mu_models.end(), f );
if( ii == mu_models.end() )
return std::pair<u32,u32>(u32(-1), u32(-1));
return std::pair<u32,u32>(u32(ii-mu_models.begin()), face_id );
}
void read( INetReader &r, CDB::MODEL &m )
{
verts.clear();
tris.clear();
r_pod_vector( r, verts );
u32 tris_count = r.r_u32();
tris.resize( tris_count );
for( u32 i = 0; i < tris_count; ++i)
::read( r, tris[i] );
m.build( &*verts.begin(), (int)verts.size(), &*tris.begin(), (int)tris.size() );
verts.clear();
tris.clear();
}
void dump_list_wnd(){
Msg("------Total wnds %d",dbg_list_wnds.size());
xr_vector<DBGList>::iterator _it = dbg_list_wnds.begin();
for(;_it!=dbg_list_wnds.end();++_it)
if(!(*_it).closed)
Msg("--leak detected ---- wnd = %d",(*_it).num);
}
u32 PlaceData(xr_vector<vecW> &C, vecW &P)
{
if (P.size()>1) {
std::sort (P.begin(),P.end());
vecW::iterator I = std::unique (P.begin(),P.end());
P.erase(I,P.end());
}
// Search placeholder
u32 sz = P.size();
u32 pos = 0;
for (xr_vector<vecW>::iterator it=C.begin(); it!=C.end(); it++)
{
u32 S = it->size();
if (S!=sz) { pos+=S+1; continue; }
if (0!=memcmp(it->begin(),P.begin(),S*sizeof(u16))) { pos+=S+1; continue; }
// Ok-Ob :)
goto exit;
}
// If we get here - need to register _new set of data
C.push_back(P);
exit:
P.clear();
return pos*sizeof(u16);
}
void CallFunctions (xr_vector<luabind::functor<void> >& v)
{
xr_vector<luabind::functor<void> >::iterator it = v.begin();
for(;it!=v.end();++it){
if( (*it).is_valid() ) (*it)();
}
}
void vec_spetial_clear( xr_vector<T> &v )
{
typename xr_vector<T>::iterator i = v.begin(), e = v.end();
for(;i!=e;++i)
clear(*i);
v.clear();
}
void vec_clear( xr_vector<T*> &v )
{
typename xr_vector<T*>::iterator i = v.begin(), e = v.end();
for(;i!=e;++i)
xr_delete(*i);
v.clear();
}
CUIWindow::~CUIWindow()
{
VERIFY( !(GetParent()&&IsAutoDelete()) );
CUIWindow* parent = GetParent();
bool ad = IsAutoDelete();
if( parent && !ad )
parent->CUIWindow::DetachChild( this );
DetachAll();
if( GetPPMode() )
MainMenu()->UnregisterPPDraw (this);
#ifdef LOG_ALL_WNDS
xr_vector<DBGList>::iterator _it = dbg_list_wnds.begin();
bool bOK = false;
for(;_it!=dbg_list_wnds.end();++_it){
if( (*_it).num==m_dbg_id && !(*_it).closed){
bOK = true;
(*_it).closed = true;
dbg_list_wnds.erase(_it);
break;
}
if( (*_it).num==m_dbg_id && (*_it).closed){
Msg("--CUIWindow [%d] already deleted", m_dbg_id);
bOK = true;
}
}
if(!bOK)
Msg("CUIWindow::~CUIWindow.[%d] cannot find window in list", m_dbg_id);
#endif
}
void CLevelChanger::net_Destroy ()
{
inherited ::net_Destroy ();
xr_vector<CLevelChanger*>::iterator it = std::find(g_lchangers.begin(), g_lchangers.end(), this);
if(it != g_lchangers.end())
g_lchangers.erase(it);
}
void SaveDATA(IWriter &fs, xr_vector<vecW> &C)
{
for (xr_vector<vecW>::iterator it=C.begin(); it!=C.end(); it++)
{
fs.Wword(it->size());
fs.write(it->begin(),it->size()*sizeof(u16));
}
}
BOOL reclaim (xr_vector<T*>& vec, const T* ptr)
{
xr_vector<T*>::iterator it = vec.begin ();
xr_vector<T*>::iterator end = vec.end ();
for (; it!=end; it++)
if (*it == ptr) { vec.erase (it); return TRUE; }
return FALSE;
}
void CUIActorMenu::highlight_ammo_for_weapon( PIItem weapon_item, CUIDragDropListEx* ddlist )
{
VERIFY( weapon_item );
VERIFY( ddlist );
static xr_vector<shared_str> ammo_types;
ammo_types.clear_not_free();
CWeapon* weapon = smart_cast<CWeapon*>(weapon_item);
if ( !weapon )
{
return;
}
ammo_types.assign( weapon->m_ammoTypes.begin(), weapon->m_ammoTypes.end() );
CWeaponMagazinedWGrenade* wg = smart_cast<CWeaponMagazinedWGrenade*>(weapon_item);
if ( wg )
{
if ( wg->IsGrenadeLauncherAttached() && wg->m_ammoTypes2.size() )
{
ammo_types.insert( ammo_types.end(), wg->m_ammoTypes2.begin(), wg->m_ammoTypes2.end() );
}
}
if ( ammo_types.size() == 0 )
{
return;
}
xr_vector<shared_str>::iterator ite = ammo_types.end();
u32 const cnt = ddlist->ItemsCount();
for ( u32 i = 0; i < cnt; ++i )
{
CUICellItem* ci = ddlist->GetItemIdx(i);
PIItem item = (PIItem)ci->m_pData;
if ( !item )
{
continue;
}
CWeaponAmmo* ammo = smart_cast<CWeaponAmmo*>(item);
if ( !ammo )
{
highlight_addons_for_weapon( weapon_item, ci );
continue; // for i
}
shared_str const& ammo_name = item->object().cNameSect();
xr_vector<shared_str>::iterator itb = ammo_types.begin();
for ( ; itb != ite; ++itb )
{
if ( ammo_name._get() == (*itb)._get() )
{
ci->m_select_armament = true;
break; // itb
}
}
}//for i
}
void read( INetReader &r, CDB::MODEL* &m, xrLC_GlobalData &lc_global_data )
{
verts.clear();
tris.clear();
r_pod_vector( r, verts );
u32 tris_count = r.r_u32();
tris.resize( tris_count );
for( u32 i = 0; i < tris_count; ++i)
::read( r, tris[i], lc_global_data );
VERIFY(!m);
m = xr_new<CDB::MODEL> ();
m->build( &*verts.begin(), (int)verts.size(), &*tris.begin(), (int)tris.size() );
verts.clear();
tris.clear();
}
bool bfGetActionSuccessProbability(GroupHierarchyHolder::MEMBER_REGISTRY &Members, const xr_vector<const CEntityAlive *> &VisibleEnemies, float fMinProbability, CBaseFunction &fSuccessProbabilityFunction)
{
int i = 0, j = 0, I = (int)Members.size(), J = (int)VisibleEnemies.size();
xr_vector<const CEntityAlive*>::const_iterator II = VisibleEnemies.begin();
for ( ; (i < I) && (j < J); ) {
ai().ef_storage().non_alife().member() = smart_cast<CEntityAlive *>(Members[i]);
if (!(ai().ef_storage().non_alife().member()) || !(ai().ef_storage().non_alife().member()->g_Alive())) {
++i;
continue;
}
ai().ef_storage().non_alife().enemy() = *II;
if (!(ai().ef_storage().non_alife().enemy()) || !(ai().ef_storage().non_alife().enemy()->g_Alive())) {
++j;
++II;
continue;
}
float fProbability = fSuccessProbabilityFunction.ffGetValue()/100.f, fCurrentProbability;
if (fProbability > fMinProbability) {
fCurrentProbability = fProbability;
for (++j; (i < I) && (j < J); ++j) {
ai().ef_storage().non_alife().enemy() = *II;
if (!(ai().ef_storage().non_alife().enemy()) || !(ai().ef_storage().non_alife().enemy()->g_Alive())) {
++j;
++II;
continue;
}
fProbability = fSuccessProbabilityFunction.ffGetValue()/100.f;
if (fCurrentProbability*fProbability < fMinProbability) {
++i;
break;
}
else
fCurrentProbability *= fProbability;
}
}
else {
fCurrentProbability = 1.0f - fProbability;
for (++i; (i < I) && (j < J); ++i) {
ai().ef_storage().non_alife().member() = smart_cast<CEntityAlive *>(Members[i]);
if (!(ai().ef_storage().non_alife().member()) || !(ai().ef_storage().non_alife().member()->g_Alive())) {
++i;
continue;
}
fProbability = 1.0f - fSuccessProbabilityFunction.ffGetValue()/100.f;
if (fCurrentProbability*fProbability < (1.f - fMinProbability)) {
++II;
++j;
break;
}
else
fCurrentProbability *= fProbability;
}
}
}
return(j >= J);
}
void dbg_draw_geoms(xr_vector<CODEGeom*>& m_weapon_geoms)
{
xr_vector<CODEGeom*>::iterator ii =m_weapon_geoms.begin(), ee = m_weapon_geoms.end();
for( ;ii!=ee; ++ii )
{
CODEGeom *g =(*ii);
g->dbg_draw( 0.01f, D3DCOLOR_XRGB( 0, 255, 100 ), Flags32() );
}
}
void transfer(const char *name, xr_vector<T> &dest, IReader& F, u32 chunk)
{
IReader* O = F.open_chunk(chunk);
u32 count = O?(O->length()/sizeof(T)):0;
clMsg ("* %16s: %d",name,count);
if (count)
{
dest.reserve(count);
dest.insert (dest.begin(), (T*)O->pointer(), (T*)O->pointer() + count);
}
if (O) O->close ();
}
static void restore_fixes( )
{
struct refix {
void operator () (anim_bone_fix* fix)
{
fix->refix();
}
} rf;
std::for_each( saved_fixes.begin(), saved_fixes.end(), rf );
saved_fixes.clear();
}
void sort_tlist_mat
(
xr_vector<mapMatrixTextures::TNode*,render_alloc<mapMatrixTextures::TNode*> >& lst,
xr_vector<mapMatrixTextures::TNode*,render_alloc<mapMatrixTextures::TNode*> >& temp,
mapMatrixTextures& textures,
BOOL bSSA
)
{
int amount = textures.begin()->key->size();
if (bSSA)
{
if (amount<=1)
{
// Just sort by SSA
textures.getANY_P (lst);
std::sort (lst.begin(), lst.end(), cmp_textures_ssa_mat);
}
else
{
// Split into 2 parts
mapMatrixTextures::TNode* _it = textures.begin ();
mapMatrixTextures::TNode* _end = textures.end ();
for (; _it!=_end; _it++) {
if (_it->val.ssa > r_ssaHZBvsTEX) lst.push_back (_it);
else temp.push_back (_it);
}
// 1st - part - SSA, 2nd - lexicographically
std::sort (lst.begin(), lst.end(), cmp_textures_ssa_mat);
if (2==amount) std::sort (temp.begin(), temp.end(), cmp_textures_lex2_mat);
else if (3==amount) std::sort (temp.begin(), temp.end(), cmp_textures_lex3_mat);
else std::sort (temp.begin(), temp.end(), cmp_textures_lexN_mat);
// merge lists
lst.insert (lst.end(),temp.begin(),temp.end());
}
}
else
{
textures.getANY_P (lst);
if (2==amount) std::sort (lst.begin(), lst.end(), cmp_textures_lex2_mat);
else if (3==amount) std::sort (lst.begin(), lst.end(), cmp_textures_lex3_mat);
else std::sort (lst.begin(), lst.end(), cmp_textures_lexN_mat);
}
}
void CBuild::SaveTREE (IWriter &fs)
{
CMemoryWriter MFS;
Status ("Geometry buffers...");
xr_vector<u32> remap;
remap.reserve (g_tree.size());
for (u32 rid=0; rid<g_tree.size(); rid++) {
OGF* o = dynamic_cast<OGF*> (g_tree[rid]);
if (o) remap.push_back(rid);
}
std::stable_sort (remap.begin(),remap.end(),remap_order);
clMsg ("remap-size: %d / %d",remap.size(),g_tree.size());
for (u32 sid=0; sid<remap.size(); sid++) {
u32 id = remap[sid];
//clMsg ("%3d: subdiv: %d",sid,id);
g_tree[id]->PreSave (id);
}
Status ("Visuals...");
fs.open_chunk (fsL_VISUALS);
for (xr_vector<OGF_Base*>::iterator it = g_tree.begin(); it!=g_tree.end(); it++) {
u32 idx = u32(it-g_tree.begin());
MFS.open_chunk (idx);
(*it)->Save (MFS);
MFS.close_chunk ();
Progress (float(idx)/float(g_tree.size()));
}
fs.w (MFS.pointer(),MFS.size());
fs.close_chunk ();
clMsg ("Average: %d verts/%d faces, 50(%2.1f), 100(%2.1f), 500(%2.1f), 1000(%2.1f), 5000(%2.1f)",
g_batch_verts/g_batch_count,
g_batch_faces/g_batch_count,
100.f * float(g_batch_50)/float(g_batch_count),
100.f * float(g_batch_100)/float(g_batch_count),
100.f * float(g_batch_500)/float(g_batch_count),
100.f * float(g_batch_1000)/float(g_batch_count),
100.f * float(g_batch_5000)/float(g_batch_count)
);
mem_Compact ();
SaveGEOMs ("level.geom", g_VB,g_IB,g_SWI); // Normal
SaveGEOMs ("level.geomx", x_VB,x_IB,x_SWI); // Fast-Path
Status ("Shader table...");
fs.open_chunk (fsL_SHADERS);
fs.w_u32 (g_Shaders.size());
for (xr_vector<LPCSTR>::iterator T=g_Shaders.begin(); T!=g_Shaders.end(); T++)
fs.w_stringZ (*T);
fs.close_chunk ();
//mem_Compact ();
}
IC void CSmartCastStats::show ()
{
if (m_stats.empty()) {
Msg ("CONGRATULATIONS : SmartCast stats is empty!!!");
return;
}
m_temp.clear ();
m_temp.insert (m_temp.begin(),m_stats.begin(),m_stats.end());
std::sort (m_temp.begin(),m_temp.end(),CStatsPredicate());
u32 total = 0;
xr_vector<CStats>::const_iterator I = m_temp.begin();
xr_vector<CStats>::const_iterator E = m_temp.end();
for ( ; I != E; ++I)
total += (*I).m_count;
Msg ("SmartCast stats (different %d, total %d) : ",(u32)m_stats.size(),total);
I = m_temp.begin();
for ( ; I != E; ++I)
Msg ("%8d %6.2f% : smart_cast<%s>(%s)",(*I).m_count,float((*I).m_count)*100.f/float(total),(*I).m_to,(*I).m_from);
}
void lm_layer::Pack_hemi (xr_vector<u32>& dest) //.
{
dest.resize (width*height);
xr_vector<base_color>::iterator I=surface.begin ();
xr_vector<base_color>::iterator E=surface.end ();
xr_vector<u32>::iterator W=dest.begin ();
for (; I!=E; I++)
{
base_color_c C; I->_get(C);
u8 _d = u8_clr (C.sun);
u8 _h = u8_clr (C.hemi);
*W++ = color_rgba(_h,_h,_h,_d);
}
}
void CClientDlg::RemoveServerFromList (SBServer server)
{
xr_vector <HOST_NODE>::iterator it = net_Hosts.begin();
for (;it!=net_Hosts.end(); ++it)
{
HOST_NODE& N = *(it);//net_Hosts [I];
// if ( !stricmp(N.dpCharAddress, NODE->dpCharAddress))
if (N.dpServer == server)
{
net_Hosts.erase(it);
break;
}
};
};
void base_lighting::select (xr_vector<R_Light>& dest, xr_vector<R_Light>& src, Fvector& P, float R)
{
Fsphere Sphere;
Sphere.set (P,R);
dest.clear ();
R_Light* L = &*src.begin();
for (; L!=&*src.end(); L++)
{
if (L->type==LT_POINT) {
float dist = Sphere.P.distance_to(L->position);
if (dist>(Sphere.R+L->range)) continue;
}
dest.push_back(*L);
}
}
void vfOptimizeParameters(xr_vector<xr_vector<REAL> > &A, xr_vector<xr_vector<REAL> > &B, xr_vector<REAL> &C, xr_vector<REAL> &D, REAL dEpsilon, REAL dAlpha, REAL dBeta, REAL dNormaFactor, u32 dwMaxIterationCount)
{
u32 dwTestCount = (u32)B.size();
xr_vector<REAL> daGradient;
xr_vector<REAL> daDelta;
xr_vector<xr_vector<REAL> > daEvalResults; daEvalResults.resize(dwTestCount);
if (!B.size()) {
clMsg ("! ERROR : there are no parameters to fit!");
return;
}
u32 dwParameterCount = (u32)B[0].size();
C.assign (dwParameterCount,1.0f);
D.assign (dwParameterCount,0.0f);
daDelta.assign (dwParameterCount,0);
daGradient.assign (dwParameterCount,0);
{
for (u32 i=0; i<dwTestCount; i++)
daEvalResults[i].resize(dwParameterCount);
}
u32 i = 0;
REAL dFunctional = dfComputeEvalResults(daEvalResults,A,B,C,D), dPreviousFunctional;
//clMsg ("* MU-fitter: %6d : %17.8f (%17.8f)",i,dFunctional,dFunctional/dwTestCount);
do {
dPreviousFunctional = dFunctional;
dafGradient (daEvalResults, daGradient, B, dNormaFactor);
std::transform (daGradient.begin(), daGradient.end(), daGradient.begin(), std::bind2nd(std::multiplies<REAL>(), -dAlpha));
std::transform (daDelta.begin(), daDelta.end(), daDelta.begin(), std::bind2nd(std::multiplies<REAL>(), dBeta));
std::transform (daGradient.begin(), daGradient.end(), daDelta.begin(), daDelta.begin(), std::plus<REAL>());
std::transform (C.begin(), C.end(), daDelta.begin(), C.begin(), std::plus<REAL>());
std::transform (D.begin(), D.end(), daDelta.begin(), D.begin(), std::plus<REAL>());
dFunctional = dfComputeEvalResults(daEvalResults,A,B,C,D);
i++;
}
while ((((dPreviousFunctional - dFunctional)/dwTestCount) > dEpsilon) && (i <= dwMaxIterationCount));
if (dPreviousFunctional < dFunctional) {
std::transform (daDelta.begin(), daDelta.end(), daDelta.begin(), std::bind2nd(std::multiplies<REAL>(), -1));
std::transform (C.begin(), C.end(), daDelta.begin(), C.begin(), std::plus<REAL>());
std::transform (D.begin(), D.end(), daDelta.begin(), D.begin(), std::plus<REAL>());
}
dFunctional = dfComputeEvalResults(daEvalResults,A,B,C,D);
//clMsg ("* MU-fitter: %6d : %17.8f (%17.8f)",i,dFunctional,dFunctional/dwTestCount);
}
IC void construct_id_string (LPSTR result, const xr_vector<ALife::_OBJECT_ID> &restrictions)
{
xr_strcpy (result,"");
string16 temp;
u32 count = 0;
xr_vector<ALife::_OBJECT_ID>::const_iterator I = restrictions.begin();
xr_vector<ALife::_OBJECT_ID>::const_iterator E = restrictions.end();
for ( ; I != E; ++I) {
if (count)
xr_strcat (result,",");
xr_sprintf (temp,"%d",*I);
xr_strcat (result,temp);
++count;
}
}
void xrLC_GlobalData::clear_build_textures_surface( const xr_vector<u32> &exept )
{
clLog( "mem usage before clear build textures surface: %u", Memory.mem_usage() );
xr_vector<b_BuildTexture>::iterator i = textures().begin();
xr_vector<b_BuildTexture>::const_iterator e = textures().end();
xr_vector<b_BuildTexture>::const_iterator b = textures().begin();
for(;i!=e;++i)
{
xr_vector<u32>::const_iterator ff = std::find( exept.begin(), exept.end(),u32( i - b ) );
if( ff == exept.end() )
::clear((*i));
}
Memory.mem_compact();
clLog( "mem usage after clear build textures surface: %u", Memory.mem_usage() );
}
void xrStripify (xr_vector<u16> &indices, xr_vector<u16> &perturb, int iCacheSize, int iMinStripLength)
{
SetCacheSize (iCacheSize);
SetMinStripSize (iMinStripLength);
SetListsOnly (true);
// Generate strips
xr_vector<PrimitiveGroup> PGROUP;
GenerateStrips (&*indices.begin(),(u32)indices.size(),PGROUP);
R_ASSERT (PGROUP.size()==1);
R_ASSERT (PGROUP[0].type==PT_LIST);
if (indices.size()!=PGROUP[0].numIndices) throw "Stripify failed.";
// Remap indices
xr_vector<PrimitiveGroup> xPGROUP;
RemapIndices (PGROUP,u16(perturb.size()),xPGROUP);
R_ASSERT (xPGROUP.size()==1);
R_ASSERT (xPGROUP[0].type==PT_LIST);
// Build perturberation table
for(u32 index = 0; index < PGROUP[0].numIndices; index++)
{
u16 oldIndex = PGROUP[0].indices [index];
int newIndex = xPGROUP[0].indices [index];
R_ASSERT(oldIndex<(int)perturb.size());
R_ASSERT(newIndex<(int)perturb.size());
perturb[newIndex] = oldIndex;
}
// Copy indices
Memory.mem_copy (&*indices.begin(),xPGROUP[0].indices,(u32)indices.size()*sizeof(u16));
// Release memory
xPGROUP.clear ();
PGROUP.clear ();
}
IC void construct_string (LPSTR result, u32 const result_size, const xr_vector<ALife::_OBJECT_ID> &restrictions)
{
u32 count = xr_strlen(result) ? _GetItemCount(result) : 0;
xr_vector<ALife::_OBJECT_ID>::const_iterator I = restrictions.begin();
xr_vector<ALife::_OBJECT_ID>::const_iterator E = restrictions.end();
for ( ; I != E; ++I) {
CSE_ALifeDynamicObject *object = ai().alife().objects().object(*I);
if (ai().game_graph().vertex(object->m_tGraphID)->level_id() != ai().level_graph().level_id())
continue;
if (count)
xr_strcat(result,result_size,",");
xr_strcat(result,result_size,object->name_replace());
++count;
}
}
void lm_layer::Pack (xr_vector<u32>& dest)
{
dest.resize (width*height);
xr_vector<base_color>::iterator I=surface.begin();
xr_vector<base_color>::iterator E=surface.end();
xr_vector<u32>::iterator W=dest.begin();
for (; I!=E; I++)
{
base_color_c C; I->_get(C);
u8 _r = u8_clr(C.rgb.x);
u8 _g = u8_clr(C.rgb.y);
u8 _b = u8_clr(C.rgb.z);
u8 _d = u8_clr(C.sun);
*W++ = color_rgba(_r,_g,_b,_d);
}
}
void CUIMpTradeWnd::CreateHelperItems (xr_vector<shared_str>& ammo_types)
{
for ( xr_vector<shared_str>::iterator it = ammo_types.begin();
it != ammo_types.end();
++it )
{
const shared_str& ammo_name = *it;
if ( !m_store_hierarchy->FindItem (ammo_name) )
{
continue;
}
SBuyItemInfo* ammo_item = CreateItem(ammo_name, SBuyItemInfo::e_undefined, false);
ammo_item->m_cell_item->SetIsHelper (true);
TryToBuyItem (ammo_item, bf_normal, NULL);
}
}
