u16 RegisterShader (LPCSTR T) { for (u32 it=0; it<g_Shaders.size(); it++) if (0==stricmp(T,g_Shaders[it])) return it; g_Shaders.push_back (xr_strdup(T)); return g_Shaders.size ()-1; }
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(); }
BOOL QuadFit(u32 Base, u32 Size) { // ***** build horizontal line vecDW BaseLine; BaseLine.reserve(Size); // middle vertex& BaseNode = g_nodes[Base]; BaseLine.push_back(Base); // right expansion for (; BaseLine.size()<Size; ) { vertex& B = g_nodes[BaseLine.back()]; u32 RP = B.nRight(); if (RP==InvalidNode) break; if (used[RP]) break; if (!NodeSimilar(BaseNode,g_nodes[RP])) break; BaseLine.push_back(RP); } if (BaseLine.size()<Size) return FALSE; // down expansion BestQuad.clear (); BestQuad_Count = 0; BestQuad.reserve (Size); BestQuad.push_back (BaseLine); for (; BestQuad.size() < Size;) { // create _new list BestQuad.push_back (vecDW()); vecDW& src = BestQuad[BestQuad.size()-2]; vecDW& dest = BestQuad[BestQuad.size()-1]; dest.reserve (Size); // iterate on it vecDW_it I = src.begin (); vecDW_it E = src.end (); for (; I!=E; I++) { u32 id = g_nodes[*I].nBack(); if (id==InvalidNode) return FALSE; if (used[id]) return FALSE; if (!NodeSimilar(g_nodes[id],BaseNode)) return FALSE; dest.push_back (id); } } return TRUE; }
virtual void Execute() { CDeflector* D = 0; for (;;) { // Get task task_CS.Enter (); thProgress = 1.f - float(task_pool.size())/float(g_deflectors.size()); if (task_pool.empty()) { task_CS.Leave (); return; } D = g_deflectors[task_pool.back()]; task_pool.pop_back (); task_CS.Leave (); // Perform operation try { D->Light (&DB,&LightsSelected,H); } catch (...) { clMsg("* ERROR: CLMThread::Execute - light"); } } }
void CClientDlg::OnBnClickedGSRefreshList() { if (!net_Hosts.size()) return; int nItem = -1; for (int i=0; i<m_pServerList.GetItemCount(); i++) { if (m_pServerList.GetItemState(i, (UINT)-1) & LVIS_SELECTED) { nItem = i; break; } } if (nItem == -1) return; HOST_NODE N = net_Hosts[m_pServerList.GetItemData(nItem)]; UINT res = m_pServerList.GetItemState(nItem, (UINT)-1); if (!N.dpServer) return; // m_pGameSpyUpdateList.EnableWindow(FALSE); // m_pGameSpyRefreshList.EnableWindow(FALSE); m_bQuickRefresh = TRUE; ServerBrowserAuxUpdateServer(m_serverBrowser, N.dpServer, SBTrue, SBTrue); // if(!m_timerID) // m_timerID = SetTimer(TIMER_ID, TIMER_FREQUENCY, NULL); // m_pGameSpyUpdateList.EnableWindow(TRUE); // m_pGameSpyRefreshList.EnableWindow(TRUE); }
void retrive_data_from_mender_otput( vecOGF_V &vertices, vecOGF_F &faces, const xr_vector<float> &o_position, const xr_vector<float> &o_normal, const xr_vector<float> &o_tc, const xr_vector<float> &o_tangent, const xr_vector<float> &o_binormal, const xr_vector<float> &o_color, const xr_vector<int> &o_indices ) { // retriving data u32 v_cnt = o_position.size(); v_cnt /= 3; u32 o_idx = 0; for (itOGF_F face_it=faces.begin(); face_it!=faces.end(); face_it++){ OGF_Face &iF = *face_it; iF.v[0] = o_indices[o_idx++]; iF.v[1] = o_indices[o_idx++]; iF.v[2] = o_indices[o_idx++]; } vertices.clear (); vertices.resize(v_cnt); for (u32 v_idx=0; v_idx!=v_cnt; v_idx++){ OGF_Vertex &iV = vertices[v_idx]; iV.P.set (o_position[v_idx*3+0], o_position[v_idx*3+1], o_position[v_idx*3+2]); iV.N.set (o_normal[v_idx*3+0], o_normal[v_idx*3+1], o_normal[v_idx*3+2]); iV.T.set (o_tangent[v_idx*3+0], o_tangent[v_idx*3+1], o_tangent[v_idx*3+2]); iV.B.set (o_binormal[v_idx*3+0], o_binormal[v_idx*3+1], o_binormal[v_idx*3+2]); iV.UV.resize(1); iV.UV[0].set(o_tc[v_idx*3+0], o_tc[v_idx*3+1]); iV.Color._set(o_color[v_idx*3+0], o_color[v_idx*3+1], o_color[v_idx*3+2]); } }
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); }
void CreatePN(u32& group_id) { // grab results Fvector min,max; min.set(flt_max,flt_max,flt_max); max.set(flt_min,flt_min,flt_min); NodeMerged NM; for (u32 L=0; L<BestQuad.size(); L++) { vecDW& vec = BestQuad[L]; for (u32 N=0; N<vec.size(); N++) { u32 ID = vec[N]; used[ID] = true; g_nodes[ID].Group = group_id; NM.contains.push_back(ID); } } g_merged.push_back(NM); group_id++; }
int CompressSelected() { if (g_selected.size()>1) { std::sort (g_selected.begin(),g_selected.end()); vecW_IT I = std::unique (g_selected.begin(),g_selected.end()); g_selected.erase(I,g_selected.end()); } // Search placeholder u32 sz = g_selected.size(); u32 sz_bytes = sz*sizeof(u16); treeCompressPair Range = g_compress_tree.equal_range(sz); for (treeCompressIt it=Range.first; it!=Range.second; it++) { treeCompressType &V = *it; u32 entry = V.second; vecW &entry_data = g_pvs[entry]; if (0!=memcmp(entry_data.begin(),g_selected.begin(),sz_bytes)) continue; // Ok-Ob :) return entry; } // If we get here - need to register _new set of data u32 entry = g_pvs.size(); g_pvs.push_back(g_selected); g_compress_tree.insert(mk_pair(sz,entry)); return entry; }
void CBuild::SaveSectors(IWriter& fs) { CMemoryWriter MFS; Status("Processing..."); // validate & save for (u32 I=0; I<g_sectors.size(); I++) { MFS.open_chunk(I); g_sectors[I]->Validate(); g_sectors[I]->Save(MFS); MFS.close_chunk(); Progress(float(I)/float(g_sectors.size())); } fs.w_chunk(fsL_SECTORS,MFS.pointer(),MFS.size()); }
void format_register(LPCSTR ext) { if (ext&&ext[0]){ for (u32 i=0; i<exts.size(); i++) if (0==stricmp(exts[i],ext)) return; exts.push_back(xr_strdup(ext)); } }
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); }
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); }
// Calculate T&B void OGF::CalculateTB() { remove_isolated_verts( data.vertices, data.faces ); // ************************************* Declare inputs Status ( "Declarator..." ); u32 v_count_reserve = iFloor( float( data.vertices.size() )*1.33f ); u32 i_count_reserve = 3*data.faces.size(); mender_mapping_out_to_in_vert .clear( ); mender_mapping_out_to_in_vert .reserve( v_count_reserve ); mender_in_out_verts .reserve( v_count_reserve ); mender_in_out_indices .reserve( i_count_reserve ); mender_in_out_verts .clear( ); mender_in_out_indices .clear( ); fill_mender_input( data.vertices, data.faces, mender_in_out_verts, mender_in_out_indices ); u32 v_was = data.vertices.size(); u32 v_become= mender_in_out_verts.size(); clMsg ("duplication: was[%d] / become[%d] - %2.1f%%",v_was,v_become,100.f*float(v_become-v_was)/float(v_was)); // ************************************* Perform mungle Status ("Calculating basis..."); MeshMender mender ; if ( !mender.Mend ( mender_in_out_verts, mender_in_out_indices, mender_mapping_out_to_in_vert, 1, 0.5, 0.5, 0.0f, MeshMender::DONT_CALCULATE_NORMALS, MeshMender::RESPECT_SPLITS, MeshMender::DONT_FIX_CYLINDRICAL ) ) { xrDebug::Fatal (DEBUG_INFO, "NVMeshMender failed " ); //xrDebug::Fatal (DEBUG_INFO,"NVMeshMender failed (%s)",mender.GetLastError().c_str()); } // ************************************* Bind declarators // bind retrive_data_from_mender_otput( data.vertices, data.faces, mender_in_out_verts, mender_in_out_indices, mender_mapping_out_to_in_vert ); remove_isolated_verts( data.vertices, data.faces ); mender_in_out_verts .clear( ); mender_in_out_indices .clear( ); mender_mapping_out_to_in_vert .clear( ); }
void CClientDlg::ClearHostList() { // Clean up Host _list_ net_csEnumeration.Enter (); for (u32 i=0; i<net_Hosts.size(); i++) { HOST_NODE& N = net_Hosts[i]; if (N.pHostAddress) N.pHostAddress->Release(); } net_Hosts.clear (); net_csEnumeration.Leave (); };
void CSE_InventoryBox::add_offline (const xr_vector<ALife::_OBJECT_ID> &saved_children, const bool &update_registries) { CSE_ALifeDynamicObjectVisual *object = (this); for (u32 i=0, n=saved_children.size(); i<n; ++i) { CSE_ALifeDynamicObject *child = smart_cast<CSE_ALifeDynamicObject*>(ai().alife().objects().object(saved_children[i],true)); R_ASSERT (child); child->m_bOnline = false; CSE_ALifeInventoryItem *inventory_item = smart_cast<CSE_ALifeInventoryItem*>(child); VERIFY2 (inventory_item,"Non inventory item object has parent?!"); #ifdef DEBUG // if (psAI_Flags.test(aiALife)) // Msg ("[LSS] Destroying item [%s][%s][%d]",inventory_item->base()->name_replace(),*inventory_item->base()->s_name,inventory_item->base()->ID); Msg ( "[LSS][%d] Going offline [%d][%s][%d] with parent [%d][%s] on '%s'", Device.dwFrame, Device.dwTimeGlobal, inventory_item->base()->name_replace(), inventory_item->base()->ID, ID, name_replace(), "*SERVER*" ); #endif ALife::_OBJECT_ID item_id = inventory_item->base()->ID; inventory_item->base()->ID = object->alife().server().PerformIDgen(item_id); if (!child->can_save()) { object->alife().release (child); --i; --n; continue; } #ifdef DEBUG if (!client_data.empty()) Msg ("CSE_InventoryBox::add_offline: client_data is cleared for [%d][%s]",ID,name_replace()); #endif // DEBUG if (!child->keep_saved_data_anyway()) child->client_data.clear (); object->alife().graph().add (child,child->m_tGraphID,false); // object->alife().graph().attach (*object,inventory_item,child->m_tGraphID,true); alife().graph().remove (child,child->m_tGraphID); children.push_back (child->ID); child->ID_Parent = ID; } CSE_ALifeDynamicObjectVisual::add_offline(saved_children, update_registries); }
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 (); }
int CKinematics::LL_GetBoneGroups(xr_vector<xr_vector<u16> >& groups) { groups.resize (children.size()); for (u16 bone_idx=0; bone_idx<(u16)bones->size(); bone_idx++) { CBoneData* B = (*bones)[bone_idx]; for (u32 child_idx=0; child_idx<children.size(); child_idx++){ if (!B->child_faces[child_idx].empty()){ groups[child_idx].push_back(bone_idx); } } } return groups.size(); }
void SaveUVM (LPCSTR fname, xr_vector<b_rc_face>& vm) { IWriter* W = FS.w_open(fname); string256 tmp; // vertices for (u32 v_idx=0; v_idx<vm.size(); v_idx++){ b_rc_face& rcf = vm[v_idx]; sprintf (tmp,"f %d %d [%3.2f,%3.2f]-[%3.2f,%3.2f]-[%3.2f,%3.2f]",rcf.dwMaterial,rcf.dwMaterialGame, rcf.t[0].x,rcf.t[0].y, rcf.t[1].x,rcf.t[1].y, rcf.t[2].x,rcf.t[2].y); W->w_string (tmp); } FS.w_close (W); }
int xrSimulate (xr_vector<u16> &indices, int iCacheSize ) { VertexCache C(iCacheSize); int count=0; for (u32 i=0; i<indices.size(); i++) { int id = indices[i]; if (C.InCache(id)) continue; count++; C.AddEntry(id); } return count; }
void CClientDlg::OnNMClickServerslist(NMHDR *pNMHDR, LRESULT *pResult) { NMITEMACTIVATE *pAct = (NMITEMACTIVATE*)pNMHDR; *pResult = 0; if (pAct->iItem >= 0 && u32(pAct->iItem) <net_Hosts.size()) { m_pBtnJoin.EnableWindow(TRUE); } else { m_pBtnJoin.EnableWindow(FALSE); }; }
void FlushLog () { if (!no_log) { logCS.Enter (); IWriter *f = FS.w_open(logFName); if (f) { for (u32 it=0; it<LogFile.size(); it++) { LPCSTR s = *(LogFile[it]); f->w_string (s?s:""); } FS.w_close (f); } logCS.Leave (); } }
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 (); }
REAL dfComputeEvalResults(xr_vector<xr_vector<REAL> > &daEvalResults, xr_vector<xr_vector<REAL> > &A, xr_vector<xr_vector<REAL> > &B, xr_vector<REAL> &C, xr_vector<REAL> &D) { REAL dResult = 0.0; u32 dwTestCount = (u32)B.size(); u32 dwParameterCount = (u32)B[0].size(); for (u32 i=0; i<dwTestCount; i++) { for (u32 j=0; j<dwParameterCount; j++) { daEvalResults[i][j] = dfEvaluation(A[i][j],C[j],D[j]); REAL dTemp = B[i][j] - daEvalResults[i][j]; dResult += dTemp*dTemp; } } return (dResult); }
void draw_wnds_rects() { if(0==g_wnds_rects.size()) return; xr_vector<Frect>::iterator it = g_wnds_rects.begin(); xr_vector<Frect>::iterator it_e = g_wnds_rects.end(); for(;it!=it_e;++it) { Frect& r = *it; UI()->ClientToScreenScaled(r.lt, r.lt.x, r.lt.y); UI()->ClientToScreenScaled(r.rb, r.rb.x, r.rb.y); draw_rect (r,color_rgba(255,0,0,255)); }; g_wnds_rects.clear(); }
//---------------------------------------------------------------------- int CObjectSpace::GetNearest ( xr_vector<ISpatial*>& q_spatial, xr_vector<CObject*>& q_nearest, const Fvector &point, float range, CObject* ignore_object ) { q_spatial.clear_not_free ( ); // Query objects q_nearest.clear_not_free ( ); Fsphere Q; Q.set (point,range); Fvector B; B.set (range,range,range); g_SpatialSpace->q_box(q_spatial,0,STYPE_COLLIDEABLE,point,B); // Iterate xr_vector<ISpatial*>::iterator it = q_spatial.begin (); xr_vector<ISpatial*>::iterator end = q_spatial.end (); for (; it!=end; it++) { CObject* O = (*it)->dcast_CObject (); if (0==O) continue; if (O==ignore_object) continue; Fsphere mS = { O->spatial.sphere.P, O->spatial.sphere.R }; if (Q.intersect(mS)) q_nearest.push_back(O); } return q_nearest.size(); }
void CPortalTraverser::dbg_draw () { RCache.OnFrameEnd (); RCache.set_xform_world (Fidentity); RCache.set_xform_view (Fidentity); RCache.set_xform_project(Fidentity); for (u32 s=0; s<dbg_sectors.size(); s++) { CSector* S = (CSector*)dbg_sectors[s]; FVF::L verts [5]; Fbox2 bb = S->r_scissor_merged; bb.min.x = bb.min.x * 2 - 1; bb.max.x = bb.max.x * 2 - 1; bb.min.y = (1-bb.min.y) * 2 - 1; bb.max.y = (1-bb.max.y) * 2 - 1; verts[0].set(bb.min.x,bb.min.y,EPS,0xffffffff); verts[1].set(bb.max.x,bb.min.y,EPS,0xffffffff); verts[2].set(bb.max.x,bb.max.y,EPS,0xffffffff); verts[3].set(bb.min.x,bb.max.y,EPS,0xffffffff); verts[4].set(bb.min.x,bb.min.y,EPS,0xffffffff); RCache.dbg_Draw (D3DPT_LINESTRIP,verts,4); } }
void OGF::adjacent_select (xr_vector<u32>& dest, xr_vector<bool>& vmark, xr_vector<bool>& fmark) { // 0. Search for the group for (u32 fit=0; fit<faces.size(); fit++) { OGF_Face& F = faces [fit]; if (fmark[fit]) continue; // already registered // new face - if empty - just put it in, else check connectivity if (dest.empty()) { fmark[fit] = true ; dest.push_back (F.v[0]); vmark[F.v[0]]=true; dest.push_back (F.v[1]); vmark[F.v[1]]=true; dest.push_back (F.v[2]); vmark[F.v[2]]=true; } else { // check connectivity BOOL bConnected = FALSE; for (u32 vid=0; vid<3; vid++) { u32 id = F.v [vid]; // search in already registered verts for (u32 sid=0; sid<dest.size(); sid++) { if (id==dest[sid]) { bConnected = TRUE; // this face shares at least one vertex with already selected faces break; } } if (bConnected) break; } if (bConnected) { // add this face's vertices fmark[fit] = true ; if (!vmark[F.v[0]]) { dest.push_back (F.v[0]); vmark[F.v[0]]=true; } if (!vmark[F.v[1]]) { dest.push_back (F.v[1]); vmark[F.v[1]]=true; } if (!vmark[F.v[2]]) { dest.push_back (F.v[2]); vmark[F.v[2]]=true; } } } } }