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 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();
}
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();
}
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 construct_restriction_vector(shared_str restrictions, xr_vector<ALife::_OBJECT_ID> &result)
{
result.clear();
string64 temp;
u32 n = _GetItemCount(*restrictions);
for (u32 i=0; i<n; ++i) {
CObject *object = Level().Objects.FindObjectByName(_GetItem(*restrictions,i,temp));
if (!object)
continue;
result.push_back(object->ID());
}
}
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();
}
bool GetGlobalData( IAgent* agent,
DWORD sessionId )
{
if(!inlc_global_data())
{
VERIFY( agent );
net_pool.clear();
/*
IGenericStream* globalDataStream=0;
HRESULT rz = agent->GetData(sessionId, dataDesc, &globalDataStream);
if (rz!=S_OK)
return false;
*/
string_path cache_dir;
HRESULT rz = agent->GetSessionCacheDirectory( sessionId, cache_dir );
if (rz!=S_OK)
return false;
strconcat(sizeof(cache_dir),cache_dir,cache_dir,gl_data_net_file_name);
/*
IWriter* file = FS.w_open( cache_dir );
R_ASSERT(file);
file->w( globalDataStream->GetCurPointer(), globalDataStream->GetLength() );
free(globalDataStream->GetCurPointer());
FS.w_close(file);
agent->FreeCachedData(sessionId, dataDesc);
ULONG r =globalDataStream->AddRef();
r = globalDataStream->Release();
if(r>0)
globalDataStream->Release();
agent->FreeCachedData(sessionId, dataDesc);
Memory.mem_compact ();
*/
DataReadCreate( cache_dir );
return true;
}
return true;
}
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;
}
void CDeflector::RemapUV (xr_vector<UVtri>& dest, u32 base_u, u32 base_v, u32 size_u, u32 size_v, u32 lm_u, u32 lm_v, BOOL bRotate)
{
dest.clear ();
dest.reserve(UVpolys.size());
// UV rect (actual)
Fvector2 a_min,a_max,a_size;
GetRect (a_min,a_max);
a_size.sub (a_max,a_min);
// UV rect (dedicated)
Fvector2 d_min,d_max,d_size;
d_min.x = (float(base_u)+.5f)/float(lm_u);
d_min.y = (float(base_v)+.5f)/float(lm_v);
d_max.x = (float(base_u+size_u)-.5f)/float(lm_u);
d_max.y = (float(base_v+size_v)-.5f)/float(lm_v);
if (d_min.x>=d_max.x) { d_min.x=d_max.x=(d_min.x+d_max.x)/2; d_min.x-=EPS_S; d_max.x+=EPS_S; }
if (d_min.y>=d_max.y) { d_min.y=d_max.y=(d_min.y+d_max.y)/2; d_min.y-=EPS_S; d_max.y+=EPS_S; }
d_size.sub (d_max,d_min);
// Remapping
Fvector2 tc;
UVtri tnew;
if (bRotate) {
for (UVIt it = UVpolys.begin(); it!=UVpolys.end(); it++)
{
UVtri& T = *it;
tnew.owner = T.owner;
for (int i=0; i<3; i++)
{
tc.x = ((T.uv[i].y-a_min.y)/a_size.y)*d_size.x + d_min.x;
tc.y = ((T.uv[i].x-a_min.x)/a_size.x)*d_size.y + d_min.y;
tnew.uv[i].set(tc);
}
dest.push_back (tnew);
}
} else {
for (UVIt it = UVpolys.begin(); it!=UVpolys.end(); it++)
{
UVtri& T = *it;
tnew.owner = T.owner;
for (int i=0; i<3; i++)
{
tc.x = ((T.uv[i].x-a_min.x)/a_size.x)*d_size.x + d_min.x;
tc.y = ((T.uv[i].y-a_min.y)/a_size.y)*d_size.y + d_min.y;
tnew.uv[i].set(tc);
}
dest.push_back (tnew);
}
}
}
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 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();
}
static void save_fixes( IKinematics *K )
{
VERIFY( K );
saved_fixes.clear();
u16 nbb = K->LL_BoneCount();
for(u16 i = 0; i < nbb; ++i )
{
CBoneInstance &bi = K->LL_GetBoneInstance( i );
if( bi.callback() == anim_bone_fix::callback )
{
VERIFY( bi.callback_param());
anim_bone_fix* fix = (anim_bone_fix*) bi.callback_param();
VERIFY( fix->bone == &bi );
saved_fixes.push_back( fix );
}
}
}
void RearrangeTabButtons(CUITabControl* pTab, xr_vector<Fvector2>& vec_sign_places)
{
TABS_VECTOR * btn_vec = pTab->GetButtonsVector();
TABS_VECTOR::iterator it = btn_vec->begin();
TABS_VECTOR::iterator it_e = btn_vec->end();
vec_sign_places.clear ();
vec_sign_places.resize (btn_vec->size());
Fvector2 pos;
pos.set ((*it)->GetWndPos());
Fvector2 sign_sz;
sign_sz.set (9.0f+3.0f, 11.0f);
u32 idx = 0;
float btn_text_len = 0.0f;
CUIStatic* st = NULL;
for(;it!=it_e;++it,++idx)
{
if(idx!=0)
{
st = xr_new<CUIStatic>(); st->SetAutoDelete(true);pTab->AttachChild(st);
st->SetFont((*it)->GetFont());
st->SetTextColor (color_rgba(90,90,90,255));
st->SetText("//");
st->SetWndSize ((*it)->GetWndSize());
st->AdjustWidthToText();
st->SetWndPos (pos);
pos.x += st->GetWndSize().x;
}
vec_sign_places[idx].set(pos);
vec_sign_places[idx].y += iFloor(((*it)->GetWndSize().y - sign_sz.y)/2.0f);
vec_sign_places[idx].y = (float)iFloor(vec_sign_places[idx].y);
pos.x += sign_sz.x;
(*it)->SetWndPos (pos);
(*it)->AdjustWidthToText();
btn_text_len = (*it)->GetWndSize().x;
pos.x += btn_text_len+3.0f;
}
}
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);
}
~SExts()
{
for (u32 i=0; i<exts.size(); i++)
xr_free(exts[i]);
exts.clear();
}
void ProcessOne (u32 Base, u32 limit=8)
{
BestQuad.clear ();
BestQuad_Count = 0;
// ***** build horizontal line
vecDW BaseLine;
BaseLine.reserve(limit*2);
u32 BL_Left=0,BL_Right=0;
// middle
vertex& BaseNode = g_nodes[Base];
BaseLine.push_back(Base);
// left expansion
for (;;) {
vertex& B = g_nodes[BaseLine.front()];
u32 LP = B.nLeft();
if (BL_Left>limit) break;
if (LP==InvalidNode) break;
if (used[LP]) break;
if (!NodeSimilar(BaseNode,g_nodes[LP])) break;
BL_Left ++;
BaseLine.insert(BaseLine.begin(),LP);
}
// right expansion
for (;;) {
vertex& B = g_nodes[BaseLine.back()];
u32 RP = B.nRight();
if (BL_Right>limit) break;
if (RP==InvalidNode) break;
if (used[RP]) break;
if (!NodeSimilar(BaseNode,g_nodes[RP])) break;
BL_Right++;
BaseLine.push_back(RP);
}
// main cycle
// Msg("- ---");
u32 BasePos = BaseLine[BL_Left];
for (u32 left=0; left<=BL_Left; left++)
{
u32 limit_right = left+limit-1;
if (limit_right>=BaseLine.size()) limit_right=BaseLine.size()-1;
u32 limit_left = left;
if (limit_left<BL_Left) limit_left = BL_Left;
if (limit_left>limit_right) limit_left = limit_right;
for (int right=int(limit_right); right>=int(limit_left); right--)
{
// now we have range [left,right]
// expand it up and down
xr_vector<vecDW> stack_up;
xr_vector<vecDW> stack_down;
// Msg("[%2d,%2d], %d", left,right,BaseLine.size());
stack_up.reserve (limit);
stack_up.push_back (vecDW());
stack_up.back().assign (BaseLine.begin()+left,BaseLine.begin()+right+1);
stack_down.reserve (limit);
stack_down.push_back (vecDW());
stack_down.back().assign(BaseLine.begin()+left,BaseLine.begin()+right+1);
// expand up
for (;stack_up.size()<=limit;) {
// create _new list
stack_up.push_back (vecDW());
vecDW& src = stack_up[stack_up.size()-2];
vecDW& dest = stack_up[stack_up.size()-1];
dest.reserve (limit);
BOOL bFailed = FALSE;
// iterate on it
vecDW_it I = src.begin ();
vecDW_it E = src.end ();
for (; I!=E; I++)
{
u32 id = g_nodes[*I].nForward();
if (id==InvalidNode) { bFailed=TRUE; break; }
if (used[id]) { bFailed=TRUE; break; }
if (!NodeSimilar(g_nodes[id],BaseNode)){ bFailed=TRUE; break; }
dest.push_back (id);
}
if (bFailed) {
stack_up.pop_back();
break;
}
}
// expand down
for (; (stack_up.size()+stack_down.size()-1) <= limit;) {
// create _new list
stack_down.push_back(vecDW());
vecDW& src = stack_down[stack_down.size()-2];
vecDW& dest = stack_down[stack_down.size()-1];
dest.reserve (limit);
BOOL bFailed = FALSE;
// 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) { bFailed=TRUE; break; }
if (used[id]) { bFailed=TRUE; break; }
if (!NodeSimilar(g_nodes[id],BaseNode)){ bFailed=TRUE; break; }
dest.push_back (id);
}
if (bFailed) {
stack_down.pop_back();
break;
}
}
// calculate size
u32 size_z = stack_up.size()+stack_down.size()-1;
u32 size_x = stack_up.back().size();
u32 size_mix = size_z*size_x;
if (size_mix>BestQuad_Count)
{
BestQuad_Count = size_mix;
BestQuad.clear ();
BestQuad.reserve (size_z);
// transfer quad
for (u32 it=stack_up.size()-1; it>0; it--)
BestQuad.push_back(stack_up[it]);
BestQuad.insert(BestQuad.begin(),stack_down.begin(),stack_down.end());
}
}
}
}
BOOL ESceneAIMapTool::CreateNode(Fvector& vAt, SAINode& N, bool bIC)
{
// *** Query and cache polygons for ray-casting
Fvector PointUp; PointUp.set(vAt); PointUp.y += RCAST_Depth; SnapXZ (PointUp,m_Params.fPatchSize);
Fvector PointDown; PointDown.set(vAt); PointDown.y -= RCAST_Depth; SnapXZ (PointDown,m_Params.fPatchSize);
Fbox BB; BB.set (PointUp,PointUp); BB.grow(m_Params.fPatchSize/2); // box 1
Fbox B2; B2.set (PointDown,PointDown); B2.grow(m_Params.fPatchSize/2); // box 2
BB.merge (B2);
if (m_CFModel)
{
/*
for(u32 i=0; i<m_CFModel->get_tris_count(); ++i)
{
CDB::TRI* tri = (m_CFModel->get_tris()+i);
if(tri->material!=0)
Msg("non-default material");
}
*/
Scene->BoxQuery(PQ,BB,CDB::OPT_FULL_TEST,m_CFModel);
}else
Scene->BoxQuery(PQ,BB,CDB::OPT_FULL_TEST,GetSnapList());
DWORD dwCount = PQ.r_count();
if (dwCount==0){
// Log("chasm1");
return FALSE; // chasm?
}
// *** Transfer triangles and compute sector
// R_ASSERT(dwCount<RCAST_MaxTris);
static xr_vector<tri> tris; tris.reserve(RCAST_MaxTris); tris.clear();
for (DWORD i=0; i<dwCount; i++)
{
SPickQuery::SResult* R = PQ.r_begin()+i;
if (R->e_obj&&R->e_mesh)
{
CSurface* surf = R->e_mesh->GetSurfaceByFaceID(R->tag);
//. SGameMtl* mtl = GMLib.GetMaterialByID(surf->_GameMtl());
//. if (mtl->Flags.is(SGameMtl::flPassable))continue;
Shader_xrLC* c_sh = Device.ShaderXRLC.Get(surf->_ShaderXRLCName());
if (!c_sh->flags.bCollision) continue;
}
/*
if(m_CFModel)
{
u16 mtl_id = R->material;
if(std::find(m_ignored_materials.begin(), m_ignored_materials.end(), mtl_id) != m_ignored_materials.end() )
{
//. Msg("--ignore");
continue;
}
}
*/
tris.push_back (tri());
tri& D = tris.back();
Fvector* V = R->verts;
D.v[0] = &V[0];
D.v[1] = &V[1];
D.v[2] = &V[2];
D.N.mknormal(*D.v[0],*D.v[1],*D.v[2]);
if (D.N.y<=0) tris.pop_back ();
}
if (tris.size()==0){
// Log("chasm2");
return FALSE; // chasm?
}
static xr_vector<Fvector> points; points.reserve(RCAST_Total); points.clear();
static xr_vector<Fvector> normals; normals.reserve(RCAST_Total);normals.clear();
Fvector P,D; D.set(0,-1,0);
float coeff = 0.5f*m_Params.fPatchSize/float(RCAST_Count);
for (int x=-RCAST_Count; x<=RCAST_Count; x++)
{
P.x = vAt.x + coeff*float(x);
for (int z=-RCAST_Count; z<=RCAST_Count; z++) {
P.z = vAt.z + coeff*float(z);
P.y = vAt.y + 10.f;
float tri_min_range = flt_max;
int tri_selected = -1;
float range,u,v;
for (i=0; i<DWORD(tris.size()); i++){
if (ETOOLS::TestRayTriA(P,D,tris[i].v,u,v,range,false)){
if (range<tri_min_range){
tri_min_range = range;
tri_selected = i;
}
}
}
if (tri_selected>=0) {
P.y -= tri_min_range;
points.push_back(P);
normals.push_back(tris[tri_selected].N);
}
}
}
if (points.size()<3) {
// Msg ("Failed to create node at [%f,%f,%f].",vAt.x,vAt.y,vAt.z);
return FALSE;
}
//.
float rc_lim = bIC?0.015f:0.7f;
if (float(points.size())/float(RCAST_Total) < rc_lim) {
// Msg ("Partial chasm at [%f,%f,%f].",vAt.x,vAt.y,vAt.z);
return FALSE;
}
// *** Calc normal
Fvector vNorm;
vNorm.set(0,0,0);
for (DWORD n=0; n<normals.size(); n++)
vNorm.add(normals[n]);
vNorm.div(float(normals.size()));
vNorm.normalize();
/*
{
// second algorithm (Magic)
Fvector N,O;
N.set(vNorm);
O.set(points[0]);
Mgc::OrthogonalPlaneFit(
points.size(),(Mgc::Vector3*)points.begin(),
*((Mgc::Vector3*)&O),
*((Mgc::Vector3*)&N)
);
if (N.y<0) N.invert();
N.normalize();
vNorm.lerp(vNorm,N,.3f);
vNorm.normalize();
}
*/
// *** Align plane
Fvector vOffs;
vOffs.set(0,-1000,0);
Fplane PL; PL.build(vOffs,vNorm);
for (DWORD p=0; p<points.size(); p++)
{
float dist = PL.classify(points[p]);
if (dist>0) {
vOffs = points[p];
PL.build(vOffs,vNorm);
}
}
// *** Create node and register it
N.Plane.build (vOffs,vNorm); // build plane
D.set (0,1,0);
N.Plane.intersectRayPoint(PointDown,D,N.Pos); // "project" position
// *** Validate results
vNorm.set(0,1,0);
if (vNorm.dotproduct(N.Plane.n)<_cos(deg2rad(60.f))) return FALSE;
float y_old = vAt.y;
float y_new = N.Pos.y;
if (y_old>y_new) {
// down
if (y_old-y_new > m_Params.fCanDOWN ) return FALSE;
} else {
// up
if (y_new-y_old > m_Params.fCanUP ) return FALSE;
}
// *** Validate plane
{
Fvector PLP; D.set(0,-1,0);
int num_successed_rays = 0;
for (int x=-RCAST_Count; x<=RCAST_Count; x++)
{
P.x = N.Pos.x + coeff*float(x);
for (int z=-RCAST_Count; z<=RCAST_Count; z++) {
P.z = N.Pos.z + coeff*float(z);
P.y = N.Pos.y;
N.Plane.intersectRayPoint(P,D,PLP); // "project" position
P.y = PLP.y+RCAST_VALID*0.01f;
float tri_min_range = flt_max;
int tri_selected = -1;
float range,u,v;
for (i=0; i<tris.size(); i++){
if (ETOOLS::TestRayTriA(P,D,tris[i].v,u,v,range,false)){
if (range<tri_min_range){
tri_min_range = range;
tri_selected = i;
}
}
}
if (tri_selected>=0){
if (tri_min_range<RCAST_VALID) num_successed_rays++;
}
}
}
float perc = float(num_successed_rays)/float(RCAST_Total);
//. if (!bIC&&(perc < 0.5f)){
float perc_lim = bIC?0.015f:0.5f;
if (perc < perc_lim){
// Msg ("Floating node.");
return FALSE;
}
}
// *** Mask check
// ???
return TRUE;
}
bool CLevelGraph::create_straight_path(u32 start_vertex_id, const Fvector2 &start_point, const Fvector2 &finish_point, xr_vector<Fvector> &tpaOutputPoints, xr_vector<u32> &tpaOutputNodes, bool bAddFirstPoint, bool bClearPath) const
{
if (!valid_vertex_position(v3d(finish_point)))
return (false);
u32 cur_vertex_id = start_vertex_id, prev_vertex_id = start_vertex_id;
Fbox2 box;
Fvector2 identity, start, dest, dir;
identity.x = identity.y = header().cell_size()*.5f;
start = start_point;
dest = finish_point;
dir.sub (dest,start);
u32 dest_xz = vertex_position(v3d(dest)).xz();
Fvector2 temp;
Fvector pos3d;
unpack_xz (vertex(start_vertex_id),temp.x,temp.y);
if (bClearPath) {
tpaOutputPoints.clear ();
tpaOutputNodes.clear ();
}
if (bAddFirstPoint) {
pos3d = v3d(start_point);
pos3d.y = vertex_plane_y(start_vertex_id,start_point.x,start_point.y);
tpaOutputPoints.push_back(pos3d);
tpaOutputNodes.push_back(start_vertex_id);
}
float cur_sqr = _sqr(temp.x - dest.x) + _sqr(temp.y - dest.y);
for (;;) {
const_iterator I,E;
begin (cur_vertex_id,I,E);
bool found = false;
for ( ; I != E; ++I) {
u32 next_vertex_id = value(cur_vertex_id,I);
if ((next_vertex_id == prev_vertex_id) || !valid_vertex_id(next_vertex_id))
continue;
CVertex *v = vertex(next_vertex_id);
unpack_xz (v,temp.x,temp.y);
box.min = box.max = temp;
box.grow (identity);
if (box.pick_exact(start,dir)) {
Fvector2 temp;
temp.add (box.min,box.max);
temp.mul (.5f);
float dist = _sqr(temp.x - dest.x) + _sqr(temp.y - dest.y);
if (dist > cur_sqr)
continue;
Fvector2 next1, next2;
#ifdef DEBUG
next1 = next2 = Fvector2().set(0.f,0.f);
#endif
Fvector tIntersectPoint;
switch (I) {
case 0 : {
next1 = box.max;
next2.set (box.max.x,box.min.y);
break;
}
case 1 : {
next1 = box.min;
next2.set (box.max.x,box.min.y);
break;
}
case 2 : {
next1 = box.min;
next2.set (box.min.x,box.max.y);
break;
}
case 3 : {
next1 = box.max;
next2.set (box.min.x,box.max.y);
break;
}
default : NODEFAULT;
}
VERIFY (_valid(next1));
VERIFY (_valid(next2));
u32 dwIntersect = intersect(start_point.x,start_point.y,finish_point.x,finish_point.y,next1.x,next1.y,next2.x,next2.y,&tIntersectPoint.x,&tIntersectPoint.z);
if (!dwIntersect)
continue;
tIntersectPoint.y = vertex_plane_y(vertex(cur_vertex_id),tIntersectPoint.x,tIntersectPoint.z);
tpaOutputPoints.push_back(tIntersectPoint);
tpaOutputNodes.push_back(cur_vertex_id);
if (dest_xz == v->position().xz())
return (true);
cur_sqr = dist;
found = true;
prev_vertex_id = cur_vertex_id;
cur_vertex_id = next_vertex_id;
break;
}
}
if (!found)
return (false);
}
}
void CloseLog(void)
{
FlushLog ();
LogFile.clear ();
}
void CMapLocation::UpdateSpot(CUICustomMap* map, CMapSpot* sp )
{
if( map->MapName() == GetLevelName() )
{
bool b_alife = !!ai().get_alife();
if ( b_alife && m_flags.test(eHideInOffline) && !m_owner_se_object->m_bOnline )
{
return;
}
if ( b_alife && m_owner_se_object->m_flags.test(CSE_ALifeObject::flVisibleForMap) == FALSE )
{
return;
}
if ( IsGameTypeSingle() )
{
CGameTask* ml_task = Level().GameTaskManager().HasGameTask( this, true );
if ( ml_task )
{
CGameTask* active_task = Level().GameTaskManager().ActiveTask();
bool border_show = ( ml_task == active_task );
if ( m_minimap_spot )
{
m_minimap_spot->show_static_border( border_show );
}
if ( m_level_spot )
{
m_level_spot->show_static_border( border_show );
}
if ( m_complex_spot )
{
m_complex_spot->show_static_border( border_show );
}
}
}
//update spot position
Fvector2 position = GetPosition();
m_position_on_map = map->ConvertRealToLocal(position, (map->Heading())?false:true); //for visibility calculating
sp->SetWndPos (m_position_on_map);
Frect wnd_rect = sp->GetWndRect();
if ( map->IsRectVisible(wnd_rect) )
{
//update heading if needed
if( sp->Heading() && !sp->GetConstHeading() )
{
Fvector2 dir_global = CalcDirection();
float h = dir_global.getH();
float h_ = map->GetHeading()+h;
sp->SetHeading( h_ );
}
map->AttachChild (sp);
}
if ( IsGameTypeSingle() )
{
CMapSpot* s = GetSpotBorder( sp );
if ( s )
{
s->SetWndPos( sp->GetWndPos() );
map->AttachChild( s );
}
}
bool b_pointer =( GetSpotPointer(sp) && map->NeedShowPointer(wnd_rect));
if(map->Heading())
{
m_position_on_map = map->ConvertRealToLocal(position, true); //for drawing
sp->SetWndPos (m_position_on_map);
}
if(b_pointer)
UpdateSpotPointer( map, GetSpotPointer(sp) );
}
else if ( Level().name() == map->MapName() && GetSpotPointer(sp) )
{
GameGraph::_GRAPH_ID dest_graph_id;
dest_graph_id = m_owner_se_object->m_tGraphID;
map_point_path.clear();
VERIFY( Actor() );
GraphEngineSpace::CGameVertexParams params(Actor()->locations().vertex_types(),flt_max);
bool res = ai().graph_engine().search(
ai().game_graph(),
Actor()->ai_location().game_vertex_id(),
dest_graph_id,
&map_point_path,
params
);
if ( res )
{
xr_vector<u32>::reverse_iterator it = map_point_path.rbegin();
xr_vector<u32>::reverse_iterator it_e = map_point_path.rend();
xr_vector<CLevelChanger*>::iterator lit = g_lchangers.begin();
//xr_vector<CLevelChanger*>::iterator lit_e = g_lchangers.end();
bool bDone = false;
//for(; (it!=it_e)&&(!bDone) ;++it){
// for(lit=g_lchangers.begin();lit!=lit_e; ++lit){
// if((*it)==(*lit)->ai_location().game_vertex_id() )
// {
// bDone = true;
// break;
// }
// }
//}
static bool bbb = false;
if(!bDone&&bbb)
{
Msg("! Error. Path from actor to selected map spot does not contain level changer :(");
Msg("Path:");
xr_vector<u32>::iterator it = map_point_path.begin();
xr_vector<u32>::iterator it_e = map_point_path.end();
for(; it!=it_e;++it){
// Msg("%d-%s",(*it),ai().game_graph().vertex(*it));
Msg("[%d] level[%s]",(*it),*ai().game_graph().header().level(ai().game_graph().vertex(*it)->level_id()).name());
}
Msg("- Available LevelChangers:");
xr_vector<CLevelChanger*>::iterator lit,lit_e;
lit_e = g_lchangers.end();
for(lit=g_lchangers.begin();lit!=lit_e; ++lit){
GameGraph::_GRAPH_ID gid = (*lit)->ai_location().game_vertex_id();
Msg("[%d]",gid);
Fvector p = ai().game_graph().vertex(gid)->level_point();
Msg("lch_name=%s pos=%f %f %f",*ai().game_graph().header().level(ai().game_graph().vertex(gid)->level_id()).name(), p.x, p.y, p.z);
}
};
if(bDone)
{
Fvector2 position;
position.set ((*lit)->Position().x, (*lit)->Position().z);
m_position_on_map = map->ConvertRealToLocal(position, false);
UpdateSpotPointer (map, GetSpotPointer(sp));
}
else
{
xr_vector<u32>::reverse_iterator it = map_point_path.rbegin();
xr_vector<u32>::reverse_iterator it_e = map_point_path.rend();
for(; (it!=it_e)&&(!bDone) ;++it)
{
if(*ai().game_graph().header().level(ai().game_graph().vertex(*it)->level_id()).name()==Level().name())
break;
}
if(it!=it_e)
{
Fvector p = ai().game_graph().vertex(*it)->level_point();
if(Actor()->Position().distance_to_sqr(p)>45.0f*45.0f)
{
Fvector2 position;
position.set (p.x, p.z);
m_position_on_map = map->ConvertRealToLocal(position, false);
UpdateSpotPointer (map, GetSpotPointer(sp));
}
}
}
}
}
}
