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