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