eHalfEdge Class Reference

#include <eTess2.h>

Inheritance diagram for eHalfEdge:

[legend]

Collaboration diagram for eHalfEdge:

[legend]

List of all members.

Public Member Functions
	eHalfEdge (ePoint *a, ePoint *b, eWall *w=NULL)
void	SetWall (eWall *w)
void	ClearWall (void)
void	SetOther (eHalfEdge *e)
void	Destroy ()
REAL	Ratio (const eCoord &c) const
eCoord	Vec () const
bool	Movable () const
bool	Splittable () const
void	Split (eHalfEdge *&e1, eHalfEdge *&e2, ePoint *s)
eCoord	IntersectWithCareless (const eHalfEdge *e2) const
ePoint *	IntersectWith (const eHalfEdge *e2) const
void	CopyIntoGrid (eGrid *grid, bool change_grid=1)
bool	Simplify (eGrid *grid)
void	Print (std::ostream &s) const
ePoint *	Point () const
eFace *	Face () const
eHalfEdge *	Other () const
eHalfEdge *	Next () const
eWall *	CrossesNewWall (const eGrid *grid) const
Static Public Member Functions
static void	FindPath (const eCoord &originPoint, const eFace *originFace, const eCoord &targetPoint, const eFace *targetFace, const eGameObject *gameObject, ePath &path)
static void	ClearPathData ()
Protected Member Functions
REAL	MinPathLength ()
void	SetMinPathLength (REAL length, tHeapBase &heap, ePATH_ORIGIN origin)
void	PossiblePath (ePATH_ORIGIN origin, REAL minLength)
virtual tHeapBase *	Heap () const
void	Unlink ()
bool	Check () const
void	SetPoint (ePoint *p)
void	SetFace (eFace *p)
Protected Attributes
ePATH_ORIGIN	origin_
int	ID
tJUST_CONTROLLED_PTR< ePoint >	point
tJUST_CONTROLLED_PTR< eFace >	face
tJUST_CONTROLLED_PTR< eHalfEdge >	next
tJUST_CONTROLLED_PTR< eHalfEdge >	prev
tJUST_CONTROLLED_PTR< eHalfEdge >	other
Private Member Functions
	~eHalfEdge ()
	eHalfEdge (ePoint *p=NULL)
Friends
class	eDual
class	ePoint
class	eFace
class	eGrid
class	eTempEdge
class	eWall
class	tReferencable< eHalfEdge >

---

Detailed Description

Definition at line 82 of file eTess2.h.

---

Constructor & Destructor Documentation

eHalfEdge::~eHalfEdge

(

)

[private]

Definition at line 160 of file eGrid.cpp.

References tHeapElement::RemoveFromHeap(), and Unlink().

{
    Unlink();
    RemoveFromHeap();
}

Here is the call graph for this function:

eHalfEdge::eHalfEdge

(

ePoint *

p = NULL

)

[private]

Definition at line 2248 of file eGrid.cpp.

References face, origin_, PATH_NONE, and point.

Referenced by eHalfEdge().

                             :ID(-1),next(NULL), prev(NULL), other(NULL)
{
    origin_ = PATH_NONE;

    point = p;
    face  = 0;
}

Here is the caller graph for this function:

eHalfEdge::eHalfEdge	(	ePoint *	a,
		ePoint *	b,
		eWall *	w = NULL
	)

Definition at line 2257 of file eGrid.cpp.

References eHalfEdge(), origin_, PATH_NONE, SetOther(), SetPoint(), SetWall(), and tASSERT.

        :ID(-1),next(NULL), prev(NULL), other(NULL)
{
    tASSERT( a !=  b);

    origin_ = PATH_NONE;

    SetPoint(a);
    SetOther(new eHalfEdge(b));
    SetWall(w);
}

Here is the call graph for this function:

---

Member Function Documentation

void eHalfEdge::SetWall

(

eWall *

w

)

[inline]

Reimplemented from eWallHolder.

Definition at line 99 of file eGrid.cpp.

References eWall::CalcLen(), eWall::Flip(), eWallHolder::GetWall(), other, eWall::RunsParallelActive(), and eWallHolder::SetWall().

Referenced by eGrid::DrawLine(), and eHalfEdge().

                                      {
    if (!w)
        return;

    // emulate rip bug
    if ( se_bugRip )
    {
        // delete old wall
        if ( other && other->GetWall() && other->GetWall()->Splittable() )
            other->eWallHolder::SetWall( 0 );

        // set new wall
        eWallHolder::SetWall( w );

        w->CalcLen();

        return;
    }

    // get other wall
    eWall* otherWall = 0;
    if ( other )
        otherWall = other->GetWall();

    // ask for permission
    if ( otherWall && !w->RunsParallelActive( otherWall ) )
        return;

    eWall* thisWall = GetWall();
    if ( thisWall )
    {
        // ask this wall for permission
        bool allowed = w->RunsParallelActive( thisWall );
        if ( otherWall )
        {
            // inform wall, but don't insert it ( since it is impossible )
            w->RunsParallelActive( otherWall );
            // st_Breakpoint();
        }
        else if ( allowed && other )
        {
            // simply flip the wall and attach it to the other edge :-)
            w->Flip();
            other->eWallHolder::SetWall(w);
            //            return;
        }
    }
    else
    {
        eWallHolder::SetWall( w );
    }

    w->CalcLen();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eHalfEdge::ClearWall

(

void

)

Definition at line 154 of file eGrid.cpp.

References NULL, and eWallHolder::SetWall().

Referenced by Simplify().

{
    eWallHolder::SetWall( NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eHalfEdge::SetOther

(

eHalfEdge *

e

)

[inline]

Definition at line 101 of file eTess2.h.

References NULL, other, and tASSERT.

Referenced by eHalfEdge().

    {
        tASSERT(e != this);

        if (e == other)
            return;

        if (other)
            other->other = NULL;

        if (e->other)
            e->other->other = NULL;

        e->other = this;
        other = e;
    }

Here is the caller graph for this function:

void eHalfEdge::Destroy

(

)

[inline]

Definition at line 119 of file eTess2.h.

References Unlink().

    {
        tJUST_CONTROLLED_PTR< eHalfEdge > holder( this );
        Unlink();
    }

Here is the call graph for this function:

REAL eHalfEdge::Ratio

(

const eCoord &

c

)

const [inline]

Definition at line 422 of file eTess2.h.

References other, and Point().

Referenced by gEnemyInfluence::AddWall(), CrossesNewWall(), gCycleChatBot::Sensor::DoExtraDetectionStuff(), eGrid::DrawLine(), IntersectWith(), eGameObject::Move(), sg_TopologyPoliceCheck(), and Split().

{
    return eCoord::V(*Point(),c,*other->Point());
}

Here is the call graph for this function:

Here is the caller graph for this function:

eCoord eHalfEdge::Vec

(

)

const [inline]

Definition at line 409 of file eTess2.h.

References other, Point(), and tASSERT.

Referenced by ClampMovement(), eFace::CorrectArea(), eGrid::DrawLine(), EdgePenalty(), eGameObject::FindCurrentFace(), FindPath(), eGrid::FindSurroundingFace(), eGameObject::Move(), eGrid::ProcessWallsInRange(), ProcessWallsRecursive(), and eWall::Vec().

                                  {
    tASSERT(other);
    return *(other->Point()) - *Point();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool eHalfEdge::Movable

(

)

const [inline]

Definition at line 132 of file eTess2.h.

References eWallHolder::GetWall(), and other.

Referenced by eFace::CorrectArea(), eGrid::DrawLine(), and Movable().

{return !GetWall() && (!other || !other->GetWall());}

Here is the call graph for this function:

Here is the caller graph for this function:

bool eHalfEdge::Splittable

(

)

const

Definition at line 1617 of file eGrid.cpp.

References eWallHolder::GetWall(), other, and eWall::Splittable().

Referenced by eGrid::DrawLine().

{
    eWall *w = GetWall();
    if (!w && other)
        w = other->GetWall();
    return !w || w->Splittable();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eHalfEdge::Split	(	eHalfEdge *&	e1,
		eHalfEdge *&	e2,
		ePoint *	s
	)

Definition at line 1626 of file eGrid.cpp.

References eWall::CalcLen(), eWallHolder::GetWall(), other, Point(), Ratio(), eWall::Split(), eWall::Splittable(), tASSERT, tERR_ERROR_INT, and tNEW.

Referenced by eGrid::DrawLine().

{
    tASSERT(other);

    e1=tNEW(eHalfEdge) (Point(),s);
    e2=tNEW(eHalfEdge) (s,other->Point());

    if (GetWall())
    {
        if (!GetWall()->Splittable())
            tERR_ERROR_INT("I told you not to split that!");
        // first, split the eWall structure:
        eWall *w1,*w2;
        GetWall()->Split(w1,w2,Ratio(*s));

        // we use the base class' function to set walls so we don't alarm the topology police
        e1->eWallHolder::SetWall(w1);
        e2->eWallHolder::SetWall(w2);
        w1->CalcLen();
        w2->CalcLen();
    }
    if (other->GetWall())
    {
        if (!other->GetWall()->Splittable())
            tERR_ERROR_INT("I told you not to split that!");
        // first, split the eWall structure:
        eWall *w1,*w2;
        other->GetWall()->Split(w2,w1,1-Ratio(*s));

        // the topology police would crash right here.
        e1->other->eWallHolder::SetWall(w1);
        e2->other->eWallHolder::SetWall(w2);
        w1->CalcLen();
        w2->CalcLen();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

eCoord eHalfEdge::IntersectWithCareless

(

const eHalfEdge *

e2

)

const

Definition at line 2272 of file eGrid.cpp.

References eCoord, EPS, other, Point(), REAL, and se_EstimatedRangeOfMult().

Referenced by eGrid::DrawLine(), eGameObject::Move(), and gPlayerWall::SplitByActive().

{
    eCoord vec  = *other->Point()     -     *Point();
    eCoord e2vec= *e2->other->Point() - *e2->Point();
    eCoord e2_t = *Point()     - *e2->Point();

    REAL inv = (vec*e2vec);
    if (fabs(inv) > EPS * se_EstimatedRangeOfMult( vec, e2vec ) )
    {
        // return intersection poin
        return (*Point()-vec*((e2_t*e2vec)/inv));
    }
    else
    {
        // lines lie almost parallel; return "inverse center of gravity" ( the swapped
        // weighting is intentional, the smaller line should have a bigger influence )
        REAL m1 = vec.Norm();
        REAL m2 = e2vec.Norm();
        if ( m1 + m2 <= 0 ) // sanity check weights
            m1=m2=1;
        return ((*Point() + *other->Point())*m2 + (*e2->Point() + *e2->other->Point())*m1)*(.5/(m1+m2));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ePoint * eHalfEdge::IntersectWith

(

const eHalfEdge *

e2

)

const

Definition at line 2298 of file eGrid.cpp.

References eCoord, NULL, other, Point(), Ratio(), REAL, and tNEW.

Referenced by CrossesNewWall(), and eGameObject::Move().

{
    eCoord vec  = *other->Point()     -     *Point();
    eCoord e2vec= *e2->other->Point() - *e2->Point();
    eCoord e2_t = *Point()     - *e2->Point();

    REAL div=(vec*e2vec);

    if (div==0) return NULL;

    eCoord ret=*Point()-vec*((e2_t*e2vec)/ div);


    REAL v=Ratio(ret);
    if (v<0 || v>1) return NULL;
    v=e2->Ratio(ret);
    if (v<0 || v>1) return NULL;

    return tNEW(ePoint) (ret);

}

Here is the call graph for this function:

Here is the caller graph for this function:

void eHalfEdge::CopyIntoGrid	(	eGrid *	grid,
		bool	change_grid = 1
	)

Definition at line 2321 of file eGrid.cpp.

References eGrid::DrawLine(), eWallHolder::GetWall(), eGrid::Insert(), other, Point(), and tASSERT.

                                                         {
    tASSERT(other);
    ePoint *start = grid->Insert(*Point());
    grid->DrawLine(start, *other->Point(), GetWall(), change_grid);
}

Here is the call graph for this function:

bool eHalfEdge::Simplify

(

eGrid *

grid

)

Definition at line 1835 of file eGrid.cpp.

References tRecorderSync< DATA >::Archive(), bb, eGrid::Check(), ClearWall(), eCoord, eDual::edge, F, face, eWallHolder::GetWall(), ID, eGrid::KillEdge(), eGrid::KillPoint(), next, Next(), other, Point(), point, REAL, ePoint::Replace(), se_LinkFaces(), tASSERT, and eGrid::ZombifyFace().

Referenced by eGrid::SimplifyNum().

{
    if (GetWall() && GetWall()->Deletable() && face)
    {
        ClearWall();
    }

    if (other && other->GetWall() && other->GetWall()->Deletable() && other->face)
    {
        other->ClearWall();
    }

    if (GetWall() || !other || other->GetWall() || !face || !other->face)
        return false;

    ePoint  *to_be_removed=point; // we'll remove this ePoint
    ePoint  *stay=other->point;   // and redirect all his edges to this ePoint

    // first, we find the faces that are going to be modified:
    // they are neighbours of the ePoint we'll remove.

    eHalfEdge *run = this->other->next;
    do{
        //    eFace *F = run->face; // eFace to be modified
        tASSERT(run->other);




        /*




          C  this
          A ------------ --------------- stays
          Next    |
          | 
          |r 
          |u   
          |n    
          |     
          |
          B




        */


        // if any of the to-be-modified edges is a eWall, abort the operation.
        if (run->GetWall() || run->other->GetWall() || !run->face)
            return false;

        eHalfEdge *Next = run->other->next;
        eCoord &A = *Next->other->point;
        eCoord &B = *run->other->point;
        eCoord &C = *stay;
#ifdef DEBUG
        //    eCoord &D = *to_be_removed;
        //    eCoord leftvec_b  = B-D;
        //    eCoord rightvec_b = A-D;
        //    REAL orientation_b=leftvec_b*rightvec_b;
#endif


        // if the eFace is to be modified (and not deleted), check
        // if it will flip orientation; if yes, abort.

        eCoord leftvec = B-C;
        eCoord rightvec= A-C;

        REAL orientation=leftvec*rightvec;

        if (orientation <= 0)
            return false;

        // test if the face contains a gameobject or is otherwise referenced; abort if that is the case
        // four references are nominal: three from the edges, one from the grid
        if ( !Next->face || Next->face->GetRefcount() > 4 )
            return false;

        //    tASSERT(orientation_b > 0);

        run = Next;
    }
    while (run && run->other &&  !(this == run->other->next));

    // dangerously close to the rim....
    if (!run || !run->other)
        return false;

    // Allright! everything is safe.
#ifdef DEBUG
    grid->Check();
#endif

    eHalfEdge *a  = next;
    eHalfEdge *aa = a->next;
    ePoint *A     = aa->Point();

    eHalfEdge *b  = other->next;
    eHalfEdge *bb = b->next;
    ePoint *B     = bb->Point();

    if (a->GetWall() || a->other->GetWall())
        return false;

    if (aa->GetWall() || aa->other->GetWall())
        return false;

    if (b->GetWall() || b->other->GetWall())
        return false;

    if (bb->GetWall() || bb->other->GetWall())
        return false;

    tControlledPTR< eHalfEdge > keep( this );

    int idrec = ID;
    tRecorderSync< int >::Archive( "_GRID_SIMPLIFY_REAL", 8, idrec );

    // the faces that will be removed
    tControlledPTR< eFace > killed1 = grid->ZombifyFace( face );
    tControlledPTR< eFace > killed2 = grid->ZombifyFace( other->face );

    // all faces that will replace them get added to their replacement list
    run = this->other->next->other->next;
    do{
        tASSERT(run->other);

        //       eHalfEdge *Next = run->other->next;
        eFace *F = run->face; // eFace to be modified
        tASSERT( F != killed1 );
        tASSERT( F != killed2 );
        if( F )
        {
            se_LinkFaces( killed1, F );
            se_LinkFaces( killed2, F );
        }

        run = run->other->next;
    }
    while (run && run->other &&  !(this == run));

    stay->Replace(to_be_removed);

    // kill everything that goes away:
    //  grid->KillFace( killed1 );
    //  grid->KillFace( killed2 );
    grid->KillPoint(stay);

    grid->KillEdge(this);

    to_be_removed->edge = aa->other;
    A            ->edge = a->other;
    B            ->edge = b->other;

    // sew the edges of the faces that are going to disappear together:
    a->other->SetOther(aa->other);
    b->other->SetOther(bb->other);

    grid->KillEdge(a);
    grid->KillEdge(aa);
    grid->KillEdge(b);
    grid->KillEdge(bb);

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eHalfEdge::Print

(

std::ostream &

s

)

const

Definition at line 652 of file eGrid.cpp.

References other, and Point().

Referenced by operator<<().

{ s << "[" << *Point() << "->" << *other->Point() << "]"; }

Here is the call graph for this function:

Here is the caller graph for this function:

ePoint * eHalfEdge::Point

(

)

const [inline]

Definition at line 415 of file eTess2.h.

References point.

Referenced by ePath::Add(), eGrid::AddEdge(), eGrid::AddFaceAll(), Check(), CopyIntoGrid(), eFace::CorrectArea(), eFace::Create(), CrossesNewWall(), eGrid::display_simple(), Distance(), eGrid::DrawLine(), EdgePenalty(), eWall::EndPoint(), eGameObject::FindCurrentFace(), eGrid::FindSurroundingFace(), eGrid::Insert(), eFace::Insideness(), IntersectWith(), IntersectWithCareless(), eFace::IsInside(), eCameraSensor::LookAround(), eGameObject::Move(), Print(), eGrid::ProcessWallsInRange(), ProcessWallsRecursive(), Ratio(), ePoint::Replace(), Simplify(), Split(), gAIPlayer::ThinkTrace(), ePoint::Unlink(), and Vec().

{ return point;}

Here is the caller graph for this function:

eFace * eHalfEdge::Face

(

)

const [inline]

Definition at line 418 of file eTess2.h.

References face.

Referenced by Check(), eGrid::display_simple(), eGrid::DrawLine(), EdgePenalty(), FindPath(), eGrid::FindSurroundingFace(), eFace::Insideness(), eFace::IsInside(), eGrid::ProcessWallsInRange(), ProcessWallsRecursive(), and eFace::Unlink().

{return face;}

Here is the caller graph for this function:

eHalfEdge* eHalfEdge::Other

(

)

const [inline]

Definition at line 197 of file eTess2.h.

References other.

Referenced by eGrid::AddEdge(), CanPass(), ClampMovement(), CrossesNewWall(), eWall::EndPoint(), FindPath(), eGrid::FindSurroundingFace(), eCameraSensor::LookAround(), Modifier(), Movable(), eGameObject::Move(), eGrid::ProcessWallsInRange(), ProcessWallsRecursive(), and gAIPlayer::ThinkTrace().

{return other;}

Here is the caller graph for this function:

eHalfEdge* eHalfEdge::Next

(

)

const [inline]

Definition at line 198 of file eTess2.h.

References next.

Referenced by ePath::Add(), ClampMovement(), eGameObject::FindCurrentFace(), FindPath(), eGrid::FindSurroundingFace(), eCameraSensor::LookAround(), Movable(), eGameObject::Move(), ProcessWallsRecursive(), and Simplify().

{return next;}

Here is the caller graph for this function:

void eHalfEdge::FindPath	(	const eCoord &	originPoint,
		const eFace *	originFace,
		const eCoord &	targetPoint,
		const eFace *	targetFace,
		const eGameObject *	gameObject,
		ePath &	path
	)			[static]

Definition at line 149 of file ePath.cpp.

References ePath::Add(), CanPass(), ePath::Clear(), ClearPathData(), con, CrossesNewWall(), Distance(), eDual::Edge(), EdgePenalty(), Face(), eGameObject::Grid(), tHeap< T >::Insert(), tHeap< T >::Len(), MinPathLength(), Modifier(), next, Next(), NULL, origin_, Other(), PATH_CLOSED, PATH_NEXT, PATH_OTHER_NEXT, PATH_PREV, PATH_PREV_OTHER, PATH_START, PossiblePath(), prev, REAL, tHeap< T >::Remove(), SetMinPathLength(), sqrt(), tASSERT, tERR_WARN, and Vec().

Referenced by gAIPlayer::ThinkPath().

{
    tASSERT( startFace );
    tASSERT( stopFace );
    tASSERT( gameObject );

    // cleanup previous path data (we'll keep it around for debugging)
    ClearPathData();
    path.Clear();

    // start: add the three vertices around the origin to the open list
    {
        eHalfEdge *run = startFace->Edge();
        for (int i=2; i>=0; i--)
        {
            run->SetMinPathLength( Distance(run, startPoint) + Distance(run, stopPoint), openEdges, PATH_START );

            run = run->Next();
        }
    }

    // search for a path until one of the edges of the goal face is in the closed list or we have to give up
    eHalfEdge* stopEdge = NULL;

    while (openEdges.Len() > 0 && !stopEdge)
    {
        // take the most promising HalfEdge out of the open list, put it
        // into the closed list
        // and add all possible ways from there to the open list.

        eHalfEdge *e = openEdges.Remove(0);

        int origin = e->origin_;
        origin |= PATH_CLOSED;
        e->origin_ = static_cast<ePATH_ORIGIN>(origin);

        closedEdges.Insert(e);

        // check if we are at the goal
        if (e->Face() == stopFace)
            stopEdge = e;

#ifdef DEBUG
        //      con << "examining " << *e->Point() << ", " << e->Vec() << "\n";
#endif

        eHalfEdge *next = e->Next();
        eHalfEdge *prev = NULL;

        eHalfEdge *other_next = e->Other()->Next();
        eHalfEdge *prev_other = NULL;

        // try the next HalfEdge in this triangle
        {
            if (next)
            {
                prev = next->Next();

                // check if we cross a new wall on the way
                if (!e->CrossesNewWall(gameObject->Grid()))
                {
                    // we get this much closer to the target by going this way:
                    REAL closer  = Distance(e, stopPoint) - Distance(next, stopPoint);

                    // but have to go this much to get there:
                    REAL way     = sqrt(e->Vec().NormSquared()) * Modifier(gameObject, e);

                    // tell n that there is a possible path to it
                    next->PossiblePath(PATH_PREV, e->MinPathLength() + way - closer + EdgePenalty(e, gameObject) );
                }
            }
        }


        // try the previous HalfEdge in this triangle
        if (prev)
        {
            tASSERT(prev->Next() == e);
            prev_other = prev->Other();

            // check if we cross a new wall on the way
            if (!prev->CrossesNewWall(gameObject->Grid()))
            {
                // we get this much closer to the target by going this way:
                REAL closer  = Distance(e, stopPoint) - Distance(prev, stopPoint);

                // but have to go this much to get there:
                REAL way     = sqrt(prev->Vec().NormSquared()) * Modifier(gameObject, e);

                // tell n that there is a possible path to it
                prev->PossiblePath(PATH_NEXT, e->MinPathLength() + way - closer  + EdgePenalty(e, gameObject));
            }
        }


        // now the edges that are just around the corner. They do not
        // make the way longer, but require the passed edge to be harmless
        // to the object.

        if (other_next && CanPass(gameObject, e))
            other_next->PossiblePath(PATH_PREV_OTHER, e->MinPathLength() + EdgePenalty(e, gameObject) + .000001f);
        if (prev_other && CanPass(gameObject, prev))
            prev_other->PossiblePath(PATH_OTHER_NEXT, e->MinPathLength() + EdgePenalty(e, gameObject) + .000001f);
    }

    // no path found...
    if (!stopEdge)
    {
        ClearPathData();
        return;
    }

    // allright! Now we just go back from the goal to the origin,
    // following the crumbs of bread we left behind.

#ifdef DEBUG
    con << "Found path.\n";
    //  con << startPoint << "\n";
#endif

    path.Add(stopPoint);

    eHalfEdge* run = stopEdge;
    while (run && run->Face() != startFace)
    {
        path.Add(run);

#ifdef DEBUG
        //      con << *run->Point() << ", " << run->Vec() << "\n";
#endif

        tASSERT(run->origin_ >= PATH_CLOSED);

        switch (run->origin_-PATH_CLOSED)
        {
        case (PATH_NEXT):
                        run = run->Next();
            break;
        case (PATH_PREV):
                        run = run->Next()->Next();
            break;
        case (PATH_OTHER_NEXT):
                        run = run->Other()->Next();
            break;
        case (PATH_PREV_OTHER):
                        run = run->Next()->Next()->Other();
            break;
        default:
            tERR_WARN("Pathfinding error!\n");
            run = startFace->Edge();
        }
    }

    //  path.Add(run);
    //  path.Add(startPoint);

#ifdef DEBUG
    //  con << stopPoint << "\n";
#endif

    ClearPathData();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eHalfEdge::ClearPathData

(

)

[static]

Definition at line 111 of file ePath.cpp.

References tHeap< T >::Len(), origin_, PATH_NONE, and tHeap< T >::Remove().

Referenced by eGrid::Clear(), and FindPath().

{
    while (openEdges.Len())
    {
        eHalfEdge *e = openEdges.Remove(0);
        e->origin_ = PATH_NONE;
    }
    while (closedEdges.Len())
    {
        eHalfEdge *e = closedEdges.Remove(0);
        e->origin_ = PATH_NONE;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

eWall * eHalfEdge::CrossesNewWall

(

const eGrid *

grid

)

const

sg_netPlayerWalls(i)->Preliminary() &&

Definition at line 81 of file ePath.cpp.

References eWallHolder::GetWall(), IntersectWith(), GrowingArrayBase::Len(), NULL, Other(), Point(), Ratio(), REAL, and eGrid::wallsNotYetInserted.

Referenced by FindPath().

{
    // check all the currently drawn eWalls:
    for(int i=grid->wallsNotYetInserted.Len()-1;i>=0;i--)
    {
        const eHalfEdge *other_e=grid->wallsNotYetInserted(i)->Edge();
        if (
            other_e->Point() && other_e->Other() && other_e->Other()->Point())
        {
            tJUST_CONTROLLED_PTR< ePoint > new_cross_p=IntersectWith(other_e);
            if (new_cross_p)
            {
                REAL e_ratio =Ratio(*new_cross_p);
                REAL o_ratio =other_e->Ratio(*new_cross_p);
                if (0<=e_ratio && 1>=e_ratio &&
                        0<=o_ratio && 1>=o_ratio)
                { // find the fall
                    eWall *w = other_e->GetWall();
                    if (!w)
                        w = other_e->Other()->GetWall();

                    if (w)
                        return w;
                }
            }
        }
    }
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

REAL eHalfEdge::MinPathLength

(

)

[inline, protected]

Definition at line 216 of file eTess2.h.

References tHeapElement::Val().

Referenced by FindPath(), and PossiblePath().

{ return Val(); }   // the minimum length of a path through this edge

Here is the call graph for this function:

Here is the caller graph for this function:

void eHalfEdge::SetMinPathLength	(	REAL	length,
		tHeapBase &	heap,
		ePATH_ORIGIN	origin
	)			[protected]

Definition at line 140 of file ePath.cpp.

References Heap(), origin_, tHeapElement::SetVal(), and tASSERT.

Referenced by FindPath(), and PossiblePath().

{
    origin_ = origin;
    tHeapElement::SetVal( length, heap );

    tASSERT( &heap == Heap() );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eHalfEdge::PossiblePath	(	ePATH_ORIGIN	origin,
		REAL	minLength
	)			[protected]

Definition at line 316 of file ePath.cpp.

References MinPathLength(), origin_, PATH_CLOSED, PATH_NONE, and SetMinPathLength().

Referenced by FindPath().

{
    // nothing needs to be done if there is already a shorter path known
    if( origin_ == PATH_NONE )
    {
        // completely new entry.

        SetMinPathLength( minLength, openEdges, newOrigin );

#ifdef DEBUG
        //      con << "adding " << *Point() << ", " << Vec() << ", origin "
        //        << origin << " to open list.\n";
#endif
    }
    else if( minLength <  MinPathLength() && origin_ < PATH_CLOSED)
    {
        // just update our info; the path got shorter.
        SetMinPathLength( minLength, openEdges, newOrigin );

#ifdef DEBUG
        //      con << "updating " << *Point() << ", " << Vec() << ", origin "
        //        << origin << " to open list.\n";
#endif

    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

tHeapBase * eHalfEdge::Heap

(

)

const [protected, virtual]

Implements tHeapElement.

Definition at line 344 of file ePath.cpp.

References NULL, origin_, PATH_CLOSED, and PATH_NONE.

Referenced by SetMinPathLength().

{
    if (origin_ >= PATH_NONE)
        return NULL;
    if (origin_ >= PATH_CLOSED)
        return &closedEdges;

    return &openEdges;
}

Here is the caller graph for this function:

void eHalfEdge::Unlink

(

)

[inline, protected]

Definition at line 166 of file eGrid.cpp.

References face, next, NULL, other, point, and prev.

Referenced by Destroy(), eGrid::KillEdge(), and ~eHalfEdge().

{
    if (point && this == point->edge)
    {
        if (prev && prev->other && prev->other)
            point->edge = prev->other;
        else if (other && other->next)
            point->edge = other->next;
        else
            point->edge = 0;
    }
    if (face && this == face->edge)
    {
        if (next)
            face->edge = next;
        if (prev)
            face->edge = prev;
    }

    if (next)
        next->prev = NULL;
    if (prev)
        prev->next = NULL;
    if (other)
        other->other = NULL;

    point   = NULL;
    face    = NULL;
    prev    = NULL;
    next    = NULL;
    other   = NULL;
}

Here is the caller graph for this function:

bool eHalfEdge::Check

(

)

const [protected]

Definition at line 2331 of file eGrid.cpp.

References face, Face(), eWallHolder::GetWall(), ID, next, other, Point(), prev, eWall::Splittable(), and tASSERT.

                           {
#ifdef DEBUG
    if (other && other->next)
        tASSERT(other->next->Point() == Point());
    if (next)
        tASSERT(next->Face() == Face());
    if (next)
        tASSERT(this == next->prev);
    if (prev)
        tASSERT(this == prev->next);

    if (ID>=0)
    {
        tASSERT(!Point() || Point()->ID >=0);
        tASSERT(!Face()  || Face()->ID  >=0);
        tASSERT(!next    || next->ID    >=0);
        tASSERT(!prev    || prev->ID    >=0);
        tASSERT(!other   || other->ID   >=0);
    }
#endif

    // only the three outer edges are allowed to have missing faces
    if ( !face )
    {
        eWall* wall = GetWall();
        if ( !wall && other )
            wall = other->GetWall();
        tASSERT( wall );

        tASSERT( !wall->Splittable() );
        // the outer walls are unsplittable ( and right now are the only unsplittable
        // walls; all real walls need to be split sometimes when laid out. )
    }

    return true;
}

Here is the call graph for this function:

void eHalfEdge::SetPoint

(

ePoint *

p

)

[inline, protected]

Definition at line 416 of file eTess2.h.

References point.

Referenced by eHalfEdge(), and ePoint::Replace().

{point = p;}

Here is the caller graph for this function:

void eHalfEdge::SetFace

(

eFace *

p

)

[inline, protected]

Definition at line 419 of file eTess2.h.

References face.

Referenced by eFace::Create(), and eFace::Unlink().

{face = f;}

Here is the caller graph for this function:

---

Friends And Related Function Documentation

friend class eDual [friend]

Definition at line 83 of file eTess2.h.

friend class ePoint [friend]

Definition at line 84 of file eTess2.h.

friend class eFace [friend]

Definition at line 85 of file eTess2.h.

friend class eGrid [friend]

Definition at line 86 of file eTess2.h.

friend class eTempEdge [friend]

Definition at line 87 of file eTess2.h.

friend class eWall [friend]

Reimplemented from eWallHolder.

Definition at line 88 of file eTess2.h.

friend class tReferencable< eHalfEdge > [friend]

Definition at line 89 of file eTess2.h.

---

Member Data Documentation

ePATH_ORIGIN eHalfEdge::origin_ [protected]

Definition at line 214 of file eTess2.h.

Referenced by ClearPathData(), eHalfEdge(), FindPath(), Heap(), PossiblePath(), and SetMinPathLength().

int eHalfEdge::ID [protected]

Definition at line 233 of file eTess2.h.

Referenced by eGrid::AddEdge(), Check(), eGrid::RemoveEdge(), and Simplify().

tJUST_CONTROLLED_PTR<ePoint> eHalfEdge::point [protected]

Definition at line 234 of file eTess2.h.

Referenced by eGrid::DrawLine(), eHalfEdge(), Point(), SetPoint(), Simplify(), and Unlink().

tJUST_CONTROLLED_PTR<eFace> eHalfEdge::face [protected]

Definition at line 235 of file eTess2.h.

Referenced by Check(), eHalfEdge(), Face(), SetFace(), Simplify(), and Unlink().

tJUST_CONTROLLED_PTR<eHalfEdge> eHalfEdge::next [protected]

Definition at line 236 of file eTess2.h.

Referenced by eGrid::AddFaceAll(), Check(), ClampMovement(), eFace::CorrectArea(), eFace::Create(), eGrid::DrawLine(), FindPath(), eGrid::Insert(), eFace::Insideness(), eFace::IsInside(), Next(), Simplify(), eFace::Unlink(), ePoint::Unlink(), and Unlink().

tJUST_CONTROLLED_PTR<eHalfEdge> eHalfEdge::prev [protected]

Definition at line 237 of file eTess2.h.

Referenced by Check(), eFace::Create(), FindPath(), and Unlink().

tJUST_CONTROLLED_PTR<eHalfEdge> eHalfEdge::other [protected]

Definition at line 238 of file eTess2.h.

Referenced by eGrid::AddFaceAll(), Check(), CopyIntoGrid(), eFace::Create(), eGrid::display_simple(), eGrid::DrawLine(), eGrid::Grow(), IntersectWith(), IntersectWithCareless(), eGrid::KillEdge(), Movable(), Other(), Print(), Ratio(), ePoint::Replace(), SetOther(), SetWall(), Simplify(), eGrid::SimplifyNum(), Split(), Splittable(), ePoint::Unlink(), Unlink(), and Vec().

---

The documentation for this class was generated from the following files:

• src/engine/eTess2.h
• src/engine/eGrid.cpp
• src/engine/ePath.cpp

---