eGrid Class Reference

#include <eGrid.h>

Inheritance diagram for eGrid:

[legend]

Collaboration diagram for eGrid:

[legend]

List of all members.

Public Member Functions
	eGrid ()
int	WindingNumber () const
int	DirectionWinding (const eCoord &dir)
eCoord	GetDirection (int winding)
void	SetWinding (int number)
void	SetWinding (int number, eCoord directions[], bool normalise=true)
void	Turn (int &currentWinding, int direction)
void	SimplifyNum (int e)
void	SimplifyAll (int count=1)
void	Check () const
void	Create ()
void	Clear ()
void	Range (REAL range_squared)
void	Grow ()
void	Render (eCamera *cam, int viewer, REAL &zNear)
ePoint *	Insert (const eCoord &coord, eFace *guessFace=NULL)
eFace *	FindSurroundingFace (const eCoord &coord, eFace *start=NULL) const
ePoint *	DrawLine (ePoint *start, const eCoord &end, eWall *wal=NULL, bool change_grid=1)
const tList< eCamera > &	Cameras () const
const tList< eGameObject > &	GameObjects () const
const tList< eGameObject > &	GameObjectsInteresting () const
const tList< eGameObject > &	GameObjectsInactive () const
int	NumberOfCameras ()
const eCoord &	CameraPos (int i)
eCoord	CameraGlancePos (int i)
const eCoord &	CameraDir (int i)
REAL	CameraHeight (int i)
void	AddGameObjectInteresting (eGameObject *o)
void	RemoveGameObjectInteresting (eGameObject *o)
void	AddGameObjectInactive (eGameObject *o)
void	RemoveGameObjectInactive (eGameObject *o)
typedef void	WallProcessor (eWall *w)
void	ProcessWallsInRange (WallProcessor *proc, const eCoord &pos, REAL range, eFace *startFace)
Static Public Member Functions
static eGrid *	CurrentGrid ()
Protected Member Functions
	~eGrid ()
void	display_simple (int viewer, bool floor, bool sr_upperSky, bool sr_lowerSky, REAL flooralpha, bool eWalls, bool gameObjects, REAL &zNear)
void	AddFace (eFace *f)
void	RemoveFace (eFace *f)
void	AddEdge (eHalfEdge *e)
void	RemoveEdge (eHalfEdge *e)
void	AddPoint (ePoint *p)
void	RemovePoint (ePoint *p)
void	KillFace (eFace *f)
void	KillEdge (eHalfEdge *e)
void	KillPoint (ePoint *p)
tControlledPTR< eFace >	ZombifyFace (eFace *f)
void	AddFaceAll (eFace *f)
Protected Attributes
eAxis	axis
bool	requestCleanup
tJUST_CONTROLLED_PTR< ePoint >	A
tJUST_CONTROLLED_PTR< ePoint >	B
tJUST_CONTROLLED_PTR< ePoint >	C
tJUST_CONTROLLED_PTR< eHalfEdge >	a
tJUST_CONTROLLED_PTR< eHalfEdge >	b
tJUST_CONTROLLED_PTR< eHalfEdge >	c
REAL	maxNormSquared
eCoord	base
tList< eHalfEdge, false, true >	edges
tList< ePoint, false, true >	points
tList< eFace, false, true >	faces
tList< eGameObject >	gameObjects
tList< eGameObject >	gameObjectsInactive
tList< eGameObject >	gameObjectsInteresting
tList< eCamera >	cameras
tList< eWall >	wallsNotYetInserted
Friends
class	eCamera
class	eFace
class	eHalfEdge
class	ePoint
class	eGameObject
class	eWall
class	tReferencable< eGrid >

---

Detailed Description

Definition at line 76 of file eGrid.h.

---

Constructor & Destructor Documentation

eGrid::~eGrid

(

)

[protected]

Definition at line 2692 of file eGrid.cpp.

References NULL.

{
    if (currentGrid == this)
        currentGrid = NULL;
}

eGrid::eGrid

(

)

Definition at line 2681 of file eGrid.cpp.

        :        requestCleanup(false),
        A(NULL), B(NULL), C(NULL),
        a(NULL), b(NULL), c(NULL),
        maxNormSquared(-1),
        base(100,100)
{
    currentGrid = this;
}

---

Member Function Documentation

int eGrid::WindingNumber

(

)

const [inline]

Definition at line 93 of file eGrid.h.

References axis, and eAxis::WindingNumber().

Referenced by CheckLoop(), and gCycleMovement::SetWindingNumberWrapped().

{return axis.WindingNumber();}

Here is the call graph for this function:

Here is the caller graph for this function:

int eGrid::DirectionWinding

(

const eCoord &

dir

)

Definition at line 675 of file eGrid.cpp.

References axis, and eAxis::NearestWinding().

Referenced by gCycle::gCycle(), gCycleMovement::gCycleMovement(), and gAIPlayer::Think().

{
    return axis.NearestWinding(dir);
}

Here is the call graph for this function:

Here is the caller graph for this function:

eCoord eGrid::GetDirection

(

int

winding

)

Definition at line 683 of file eGrid.cpp.

References axis, and eAxis::GetDirection().

Referenced by gCycleMovement::DistanceToDestination(), gCycleMovement::DoTurn(), gCycle::gCycle(), gCycleMovement::GetMaxSpaceAhead(), gCycle::ReadSync(), sg_GetSensor(), gCycleMovement::Timestep(), and gJoystick::Turn().

{
    return axis.GetDirection(winding);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::SetWinding

(

int

number

)

Definition at line 691 of file eGrid.cpp.

References axis, and eAxis::Init().

Referenced by gParser::parseAxes(), and gArena::PrepareGrid().

{
    axis.Init(number);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::SetWinding	(	int	number,
		eCoord	directions[],
		bool	normalise = true
	)

Definition at line 700 of file eGrid.cpp.

References axis, and eAxis::Init().

{
    axis.Init(number, directions, normalise);
}

Here is the call graph for this function:

void eGrid::Turn	(	int &	currentWinding,
		int	direction
	)

Definition at line 708 of file eGrid.cpp.

References axis, and eAxis::Turn().

Referenced by gCycleMovement::DistanceToDestination(), gCycleMovement::DoTurn(), draw_eWall(), gCycleMovement::GetMaxSpaceAhead(), sg_GetSensor(), gCycleMovement::Timestep(), and gJoystick::Turn().

{
    axis.Turn(currentWinding, direction);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::SimplifyNum

(

int

e

)

Definition at line 2006 of file eGrid.cpp.

References tRecorderSync< DATA >::Archive(), Check(), edges, GrowingArrayBase::Len(), eHalfEdge::other, se_simplifyEdges, se_simplifyEdgesSuccess, eHalfEdge::Simplify(), and tASSERT.

Referenced by SimplifyAll().

                            {
#ifdef DEBUG
    Check();
#endif

    if (e>=0 && e < edges.Len()){
        eHalfEdge *E=edges(e);
#ifdef DEBUG
        eHalfEdge *Esave=E;
#endif
        if ( !E || !E->other )
            return;

        // this point will be removed. Make sure it is none of the points on the outer rim.
        ePoint * toBeRemoved = E->other->Point();
        if ( toBeRemoved == A || toBeRemoved == B || toBeRemoved == C )
            return;

        tRecorderSync< int >::Archive( "_GRID_SIMPLIFY", 8, e );

        if ( E->Simplify(this) )
        {
            se_simplifyEdges += se_simplifyEdgesSuccess;
        }

#ifdef DEBUG
        tASSERT(Esave);

        Check();
#endif
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::SimplifyAll

(

int

count = 1

)

Definition at line 2041 of file eGrid.cpp.

References edges, faces, GrowingArrayBase::Len(), requestCleanup, se_simplifyEdges, and SimplifyNum().

Referenced by gGame::GameLoop().

                                {
    if (requestCleanup)
    {
        requestCleanup = false;
        for (int i=faces.Len()-1; i>=0; i--)
            requestCleanup |= faces(i)->CorrectArea();
    }


    static int counter=0;

    // try to simplify at least one edge
    se_simplifyEdges++;

    for(;count>0 && se_simplifyEdges>0;count--,se_simplifyEdges--){
        counter--;

        if (counter<0 || counter>=edges.Len())
            counter=edges.Len()-1;

        SimplifyNum(counter);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::Check

(

)

const

Definition at line 205 of file eGrid.cpp.

References c, edges, faces, GrowingArrayBase::Len(), points, and tASSERT.

Referenced by Create(), DrawLine(), gGame::GameLoop(), Grow(), Insert(), gNetPlayerWall::PartialCopyIntoGrid(), gNetPlayerWall::real_CopyIntoGrid(), eGameObject::s_Timestep(), eHalfEdge::Simplify(), and SimplifyNum().

                       {
    //    return;
    if ( a )
    {
        tASSERT( a->Point() == B );
        tASSERT( a->other->Point() == C );
        tASSERT( b->Point() == C );
        tASSERT( b->other->Point() == A );
        tASSERT( c->Point() == A );
        tASSERT( c->other->Point() == B );
    }

#ifdef DEBUG_EXPENSIVE
    if (!doCheck)
        return;

    int i;
    for (i = points.Len()-1; i>=0; i--)
        points(i)->Check();

    for (i = faces.Len()-1; i>=0; i--)
        faces(i)->Check();

    for (i = edges.Len()-1; i>=0; i--)
        edges(i)->Check();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::Create

(

)

Definition at line 2071 of file eGrid.cpp.

References AddFaceAll(), c, Check(), Clear(), eCoord, eWall, maxNormSquared, requestCleanup, and tNEW.

Referenced by gArena::PrepareGrid(), and Range().

                  {
    currentGrid = this;

    if (!A)
        Clear();

    base=eCoord(20,100);

#ifdef DEBUG
    doCheck = true;
#endif
    requestCleanup = false;


    A=tNEW(ePoint) (base.Turn(1,0));
    B=tNEW(ePoint) (base.Turn(-.5,.87));
    C=tNEW(ePoint) (base.Turn(-.5,-.87));

    a=tNEW(eHalfEdge) (B,C,tNEW(eWall(this)));
    b=tNEW(eHalfEdge) (C,A,tNEW(eWall(this)));
    c=tNEW(eHalfEdge) (A,B,tNEW(eWall(this)));

    a->other->next = c->other;
    a->other->prev = b->other;
    b->other->next = a->other;
    b->other->prev = c->other;
    c->other->next = b->other;
    c->other->prev = a->other;

    AddFaceAll(tNEW(eFace) (a,b,c));

    maxNormSquared=base.NormSquared();

#ifdef DEBUG
    Check();
#endif

}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::Clear

(

)

Definition at line 2111 of file eGrid.cpp.

References c, eHalfEdge::ClearPathData(), eGameObject::DeleteAll(), eCoord, edges, faces, GrowingArrayBase::Len(), maxNormSquared, NULL, points, RemoveEdge(), RemoveFace(), and RemovePoint().

Referenced by Create(), and exit_game_grid().

                 {
    eHalfEdge::ClearPathData();

    base=eCoord(0,100);
    maxNormSquared=0;

    int i;
    for(i=faces.Len()-1; i>=0; i--)
    {
        faces(i)->Unlink();
        RemoveFace(faces(i));
    }
    for(i=points.Len()-1; i>=0; i--)
    {
        points(i)->Unlink();
        RemovePoint(points(i));
    }
    for(i=edges.Len()-1; i>=0; i--)
    {
        edges(i)->Unlink();
        RemoveEdge(edges(i));
    }


    A=B=C=NULL;
    a=b=c=NULL;

    eGameObject::DeleteAll( this );

    //  se_faceReplacements.clear();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::Range

(

REAL

range_squared

)

Definition at line 2202 of file eGrid.cpp.

References Create(), Grow(), maxNormSquared, NULL, and se_maxGridSize.

Referenced by DrawLine(), and Insert().

                                 {
    if (A==NULL)
        Create();
    //    tERR_ERROR_INT("Wanted to insert something into the nonexistant grid!");

    // the magic factor of 4 is chosen so that no points can be added outside of the
    // current tiangle abc added by Grow().
    while (NormSquared * 4 > maxNormSquared && maxNormSquared < se_maxGridSize )
        Grow();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::Grow

(

)

Definition at line 2143 of file eGrid.cpp.

References AddFaceAll(), c, Check(), eWall, maxNormSquared, NULL, eHalfEdge::other, se_maxGridSize, and tNEW.

Referenced by DrawLine(), and Range().

{
#ifdef DEBUG
    Check();
#endif

    if ( maxNormSquared > se_maxGridSize )
        return;

    base = base.Turn(-4,0);
    maxNormSquared=base.NormSquared();

    a->ClearWall();
    b->ClearWall();
    c->ClearWall();

    ePoint *newA=tNEW(ePoint) (base.Turn(1,0));
    ePoint *newB=tNEW(ePoint) (base.Turn(-.5,.87));
    ePoint *newC=tNEW(ePoint) (base.Turn(-.5,-.87));

    eHalfEdge *newa=tNEW(eHalfEdge) (newB,newC,tNEW(eWall(this)));
    eHalfEdge *newb=tNEW(eHalfEdge) (newC,newA,tNEW(eWall(this)));
    eHalfEdge *newc=tNEW(eHalfEdge) (newA,newB,tNEW(eWall(this)));

    eHalfEdge *AnewB=tNEW(eHalfEdge) (A,newB,NULL);
    eHalfEdge *AnewC=tNEW(eHalfEdge) (A,newC,NULL);
    eHalfEdge *BnewA=tNEW(eHalfEdge) (B,newA,NULL);
    eHalfEdge *BnewC=tNEW(eHalfEdge) (B,newC,NULL);
    eHalfEdge *CnewA=tNEW(eHalfEdge) (C,newA,NULL);
    eHalfEdge *CnewB=tNEW(eHalfEdge) (C,newB,NULL);

    AddFaceAll(tNEW(eFace) (a->other,BnewA,CnewA->other));
    AddFaceAll(tNEW(eFace) (b->other,CnewB,AnewB->other));
    AddFaceAll(tNEW(eFace) (c->other,AnewC,BnewC->other));

    AddFaceAll(tNEW(eFace) (newa,AnewC->other,AnewB));
    AddFaceAll(tNEW(eFace) (newb,BnewA->other,BnewC));
    AddFaceAll(tNEW(eFace) (newc,CnewB->other,CnewA));

    a=newa;
    b=newb;
    c=newc;

    A=newA;
    B=newB;
    C=newC;

    a->other->next = c->other;
    a->other->prev = b->other;
    b->other->next = a->other;
    b->other->prev = c->other;
    c->other->next = b->other;
    c->other->prev = a->other;

#ifdef DEBUG
    Check();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::Render	(	eCamera *	cam,
		int	viewer,
		REAL &	zNear
	)

Definition at line 599 of file eDisplay.cpp.

References CameraHeight(), display_simple(), ls, ModelMatrix(), ProjMatrix(), rMIRROR_ALL, rMIRROR_OBJECTS, rMIRROR_WALLS, eCamera::SetRenderingMain(), sr_floorMirror, sr_floorMirror_strength, sr_glOut, sr_lowerSky, sr_upperSky, us, and z.

                                                         {
    if (!sr_glOut)
        return;
#ifndef DEDICATED
    ProjMatrix();

    z=CameraHeight(viewer);
    if ( zNear > z )
    {
        zNear = z;
    }

    if (sr_floorMirror){
        ModelMatrix();
        glScalef(1,1,-1);

        if (z>10) z=10;
        glFrontFace(GL_CW);

        bool us=false;
        bool ls=false;

        if (sr_floorMirror>=rMIRROR_ALL){
            us=sr_upperSky;
            ls=sr_lowerSky;
        }
        else if (sr_floorMirror>=rMIRROR_WALLS){
            if (sr_lowerSky)
                ls=true;
            else if (sr_upperSky)
                us=true;
        }

        cam->SetRenderingMain(false);
        display_simple(viewer,false,
                       us,ls,
                       0,
                       sr_floorMirror>=rMIRROR_WALLS,
                       sr_floorMirror>=rMIRROR_OBJECTS,
                       zNear);
        z=CameraHeight(viewer);
        glFrontFace(GL_CCW);
        ModelMatrix();
        glScalef(1,1,-1);


        cam->SetRenderingMain(true);
        display_simple(viewer,true,
                       sr_upperSky,sr_lowerSky,
                       1-sr_floorMirror_strength,
                       true,true,zNear);

    }
    else
    {
        cam->SetRenderingMain(true);
        display_simple(viewer,true,
                       sr_upperSky,sr_lowerSky,
                       1,
                       true,true,zNear);
    }


#ifdef EVENT_DEB
    //  for(int i=eEdge_crossing.Len()-1;i>=0;i--){
    //    eEdge_crossing(i)->Render();
    //  }
#endif
#endif
}

Here is the call graph for this function:

eGrid * eGrid::CurrentGrid

(

)

[static]

Definition at line 2069 of file eGrid.cpp.

Referenced by cWidget::Map::DrawObjects(), fill_audio(), and se_Cleanup().

{return currentGrid;}

Here is the caller graph for this function:

ePoint * eGrid::Insert	(	const eCoord &	coord,
		eFace *	guessFace = NULL
	)

Definition at line 2494 of file eGrid.cpp.

References Check(), DrawLine(), FindSurroundingFace(), eHalfEdge::next, NULL, eHalfEdge::Point(), Range(), and tASSERT.

Referenced by eHalfEdge::CopyIntoGrid(), eTempEdge::CopyIntoGrid(), DrawLine(), gParser::parseObstacleWall(), gParser::parseWall(), gParser::parseWallLine(), and gParser::parseWallRect().

                                                   {
#ifdef DEBUG
    Check();
#endif
    Range(x.NormSquared());

    eFace *f = FindSurroundingFace(x, start);
    if (!f)
        return NULL;

    /*
      for(int i=faces.Len()-1;i>=0;i--)
      {
         eFace *f = faces(i);
         if (f->IsInside(x)){

    */

    eHalfEdge *run = f->edge;
    int j;
    for(j=0;j<=2;j++){
        if (*run->Point() == x)
            return run->Point();
        run = run->next;
    }
    tASSERT (run == f->edge);

#ifdef DEBUG
    // check again ( possibly with breakpoint )
    for(j=0;j<=2;j++){
        if (*run->Point() == x)
            return run->Point();
        run = run->next;
    }
    tASSERT (run == f->edge);
#endif

    return DrawLine(f->edge->Point(), x);
    /*
      break;
         }
      }
      return NULL; 
    */
}

Here is the call graph for this function:

Here is the caller graph for this function:

eFace * eGrid::FindSurroundingFace	(	const eCoord &	coord,
		eFace *	start = NULL
	)			const

Definition at line 2543 of file eGrid.cpp.

References con, eCoord, eDual::Edge(), eHalfEdge::Face(), faces, eDual::ID, in, eFace::IsInside(), GrowingArrayBase::Len(), eHalfEdge::Next(), NULL, eHalfEdge::Other(), eHalfEdge::Point(), REAL, score, tASSERT, and eHalfEdge::Vec().

Referenced by gCycleExtrapolator::gCycleExtrapolator(), Insert(), and ProcessWallsInRange().

                                                                             {
    if (faces.Len()<1)
        return NULL;

    if (!currentFace || currentFace->ID < 0 || currentFace->ID >= faces.Len() || faces(currentFace->ID) != currentFace)
        currentFace=faces(0);

    int timeout=faces.Len()+2;

    while (currentFace && timeout >0 && !currentFace->IsInside(pos)){
        timeout--;

        eHalfEdge *run   = currentFace->Edge(); // runs through all edges of the face
        eHalfEdge *best  = NULL;                // the best face to leave
        eHalfEdge *first = NULL;
        eHalfEdge *in    = NULL;
        REAL bestScore   = 0;


        // look for the best way out
        while(run != first)
        {
            if (run == in)
            {
                run = run->Next();
                continue;
            }

            if ( run->Other() && run->Other()->Face() )
            {
                eCoord vec=pos - (*run->Point()); // the vector to our destination

                REAL score = run->Vec() * vec;

                if (score > bestScore)
                {
                    best      = run;
                    bestScore = score;
                }
            }

            if (!first)
                first = run;

            run = run->Next();
        }

        if (best)
        {
            in = best->Other();
            tASSERT(in);

            currentFace = in->Face();
            timeout--;
        }
        else
        {
            timeout = 0;
            //                  st_Breakpoint();
        }
    }

    if (timeout<=0){ // normal way failed
#ifdef DEBUG
        con << "WARNING! FindSurroundingFace failed.\n";
#endif
        // do it the hard way:
        for(int i=faces.Len()-1;i>=0;i--)
            if(faces(i)->IsInside(pos)){
                currentFace=faces(i);
                i=-1;
            }
    }

    return currentFace;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ePoint * eGrid::DrawLine	(	ePoint *	start,
		const eCoord &	end,
		eWall *	wal = NULL,
		bool	change_grid = 1
	)

Definition at line 720 of file eGrid.cpp.

References AddFaceAll(), bb, c, Check(), eFace::CorrectArea(), d, eCoord, eDual::edge, ePoint, EPS, F, eHalfEdge::Face(), G, eWallHolder::GetWall(), good(), Grow(), Insert(), eHalfEdge::IntersectWithCareless(), KillEdge(), KillPoint(), eHalfEdge::Movable(), eHalfEdge::next, NULL, eHalfEdge::other, eHalfEdge::point, eHalfEdge::Point(), Range(), eHalfEdge::Ratio(), REAL, ePoint::Replace(), requestCleanup, score, se_EstimatedRangeOfMult(), se_LinkFaces(), se_maxGridSize, se_simplifyEdges, se_simplifyEdgesNew, eHalfEdge::SetWall(), eHalfEdge::Split(), eWall::Splittable(), eHalfEdge::Splittable(), st_Breakpoint(), tASSERT, tERR_ERROR_INT, tNEW, eHalfEdge::Vec(), and ZombifyFace().

Referenced by eHalfEdge::CopyIntoGrid(), eTempEdge::CopyIntoGrid(), gParser::DrawRim(), and Insert().

                                                                                    {
    // for every edge we add, allow to simplify
    se_simplifyEdges += se_simplifyEdgesNew;

    // prepare a teporary edge so we always know what the wall we are placing looks like
    tStackObject< eTempEdge > toBePlaced( *start, end, w );
    //tJUST_CONTROLLED_PTR< eWall > wal( w );

    // sanity check
    if ( !finite( end.x ) || !finite( end.y ) )
        return start;

    Range(end.NormSquared());
    int restart=1;
    //  eEdge *todo=tNEW(eEdge) (start,end,wal);


    // now the loop: go from source to destination,
    // "rotate" the edges we cross out of our way (if possible)
    // or cut them in half.

    tJUST_CONTROLLED_PTR<eHalfEdge> currentEdge  = NULL;
    // the edge we are currently considering.
    // the line we are to draw starts at currentEdge->Point()
    // and goes into currentEdge->Face().


    REAL left_test,right_test;
    int exactly_onLeft=0;

    tASSERT(start->edge);

#ifdef DEBUG
    bool foundCurrentEdge;
    static const int laststarts_max = 10;
    ePoint *laststarts[laststarts_max];
#endif

    eCoord dir=eCoord(1,1); // the direction we are going

    int timeout = se_drawLineTimeout;

    // distance to end to know when we are going backwards
    REAL distToEnd = ( *start - end ).NormSquared();
    ePoint * lastStart = start;

    bool goon=1;
    while (goon && dir.NormSquared()>0){
#ifdef DEBUG
        static int count = 0;
        count++;
        //    if (count == 40)
        //      st_Breakpoint();
#endif

        dir=end-*start; // the direction we are going

        // check if we got closer to the end, if not, accelerate timeout and set breakpoint
        REAL newDistToEnd = dir.NormSquared();
        // std::cout << distToEnd << ", " << newDistToEnd << "\n";
        if ( newDistToEnd > distToEnd && start != lastStart )
        {
            //st_Breakpoint();
            timeout -= 100;
        }
        distToEnd = newDistToEnd;
        lastStart = start;

#ifdef DEBUG
        for (int i = laststarts_max-1; i>=1; i--)
            laststarts[i] = laststarts[i-1];

        laststarts[0] = start;

        if (timeout < 10)
            st_Breakpoint();
#endif

        if (timeout-- < 0)
        {
            requestCleanup = true;
            return start;  // give up.
        }

#ifdef DEBUG
        Check();
#endif

        // first, we need to find the first eFace:
        //    int i;

#ifdef DEBUG
        //    if (doCheck && start->id == 4792)
        //      st_Breakpoint();
#endif

        tASSERT(restart || currentEdge);

        if (restart){
            exactly_onLeft = -1;

            eHalfEdge *run  = start->edge;
            tASSERT(run);
            eHalfEdge *stop = run;

            eCoord lvec = run->Vec();
            eCoord rvec;
            left_test = lvec * dir;

            eHalfEdge *best = NULL;
            REAL best_score = -100;

            currentEdge = NULL;

            while (run)
            {
                eHalfEdge *next = run->next->next;
                tASSERT(next->next = run);
                next = next->other;

                tASSERT(next->Point() == start);

                right_test = left_test;
                rvec = lvec;
                lvec = next->Vec();
                left_test = lvec * dir;

                if (right_test <= 0 && left_test >= 0)
                {
                    bool good = rvec * lvec < 0 && right_test < 0;
                    if (good)
                        next = NULL;

                    if (good || !currentEdge)
                    {
                        currentEdge = run;

                        // are dir and lvec exactly on one line?
                        exactly_onLeft=(left_test<=EPS * EPS * se_EstimatedRangeOfMult(lvec,dir));
                    }
                }

                REAL score = right_test * left_test;
                if (right_test < 0 && left_test < 0)
                    score *= -1;     // here, - * - still is -.....

                if (!best || score > best_score  && rvec * lvec < 0
                   )
                    best = run;

                run = next;
                if (run == stop)
                    run = NULL;
            }

#ifdef DEBUG
            foundCurrentEdge = currentEdge;
            //      tASSERT(run || currentEdge);
#endif


            if (!currentEdge && best)
            {
                if (restart >= 3)
                {
                    requestCleanup = true;
                    // give up.
                    // st_Breakpoint();
                    return start;
                }

                start = Insert(*start, best->Face());
                restart ++;
                continue;

                currentEdge = best;
            }

            if (!currentEdge)
                tERR_ERROR_INT("Point " << *start << " does not have a eFace in direction "
                               << dir << "!");
            // I know this bug happens a lot more often than"
            //  " I'd like to. Don't send a bug report!");

            restart=0;
        }

        if (start != currentEdge->Point())
            tERR_ERROR_INT("currentEdge not correct!");

        eHalfEdge *rightFromCurrent = currentEdge->next;
        eHalfEdge *leftFromCurrent  = rightFromCurrent->next;
        tASSERT (currentEdge == leftFromCurrent->next);
        // are we finished?

        if (exactly_onLeft<0)
        {
            eCoord lvec = leftFromCurrent->Vec();
            exactly_onLeft =  dir * lvec < EPS * EPS * se_EstimatedRangeOfMult(lvec, dir);
        }

        eCoord left_point_to_dest = end - *(leftFromCurrent->Point());
        eCoord lvec               = rightFromCurrent->Vec();

        REAL test = lvec * left_point_to_dest;
        if(test<0){
            // endpoint lies within current eFace; cut it into three and be finnished.

            // XXX have to check that we didnt start from a edge that jumps
            // to another field. If thats the case, then recall drawLine on the
            // other field
            goon=0;

            /*
              Should this figure get distorted, align the :

              :   C        a        B
              :   #################
              :   #\           _/#
              :   # \ cc   bb_/ #
              :   #  \     _/  #
              :   #   \  _/  ##
              : b #   D\/   #
              :   #    /  ##  c
              :   # aa/  #
              :   #  / ##
              :   # / #
              :   #/##
              :   ##
              :   A


            */

            ePoint *A=currentEdge->Point();

            if ((*A) == end){
#ifdef DEBUG
                Check();
#endif
                return A;
            }
            else{
                eHalfEdge* a=rightFromCurrent;
                eHalfEdge* b=leftFromCurrent;
                eHalfEdge* c=currentEdge;

                ePoint*    B=a->Point();
                ePoint*    C=b->Point();

                if ((*B) == end)
                {
                    c->SetWall(toBePlaced.Wall());
                    return B;
                }

                if ((*C) == end)
                {
                    tASSERT( b->other );
                    b->other->SetWall(toBePlaced.Wall());
                    return C;
                }

                if(!exactly_onLeft)
                {
                    ePoint*    D=tNEW(ePoint(end));
#ifdef DEBUG
                    Check();
#endif
                    tControlledPTR< eFace > oldFace = ZombifyFace(a->Face());

                    // no problem: D really lies within current eFace.
                    // just split it in three parts:

                    eHalfEdge *aa = tNEW(eHalfEdge) (A, D);
                    eHalfEdge *bb = tNEW(eHalfEdge) (B, D);
                    eHalfEdge *cc = tNEW(eHalfEdge) (C, D);

                    //    aa->SetOther(   tNEW(eHalfEdge) (D));
                    //      bb->SetOther(   tNEW(eHalfEdge) (D));
                    //    cc->SetOther(   tNEW(eHalfEdge) (D));

                    AddFaceAll(tNEW(eFace) (b,aa,cc->other, oldFace ));
                    AddFaceAll(tNEW(eFace) (bb,aa->other,c, oldFace ));
                    AddFaceAll(tNEW(eFace) (bb->other,a,cc, oldFace ));

                    aa->SetWall(toBePlaced.Wall());

#ifdef DEBUG
                    Check();
#endif
                    return D;
                }
                else // exactly_onLeft
                {
                    /*
                      Should this figure get distorted, align the ":"

                      Bad luck, D lies on eEdge b. We are going to need
                      the other triangle touching b.


                      :          C
                      :          #
                      :         ####
                      :        # #  ##
                      :       #  #    ##
                      :  e2  #   #      ##
                      :     #    #        ##  a
                      :    #   D X          ##
                      : E #      #            ##
                      :   #      # b            ##
                      :    #     #                ## B
                      :     #    #              ##
                      :     #    #            ##
                      :      #   #          ##
                      :  e1   #  #        ##
                      :       #  #      ##   c
                      :        # #    ##
                      :         ##  ##
                      :         ####
                      :          #
                      :          A

                      Make four new faces around D. 4 new half 
                      segments DA, DB, DC and DE are created.
                      :          C
                      :          #
                      :         #|##
                      :        # |  ##
                      :       #  | DC ##
                      :  e2  #   |      ##
                      :     #    | D      ##  a
                      :    #  ___X____      ##
                      : E #__/   |    \___    ##
                      :   #  DE  |     DB \___  ##
                      :    #     |            \___## B
                      :     #    | DA           ##
                      :     #    |            ##
                      :      #   |          ##
                      :  e1   #  |        ##
                      :       #  |      ##   c
                      :        # |    ##
                      :         #|  ##
                      :         #|##
                      :          #
                      :          A

                    */

                    tASSERT(b->other);

                    // eFace *G=b->other->face;

                    // tASSERT(G);

                    eHalfEdge *e1=b->other->next;
                    eHalfEdge *e2=e1->next;
                    tASSERT(e2);
                    ePoint *E=e2->point;
                    tASSERT(E);
                    // easy: edge is just right
                    if (*E == end)
                    {
                        e2->other->SetWall(toBePlaced.Wall());
                        return E;
                    }

                    // ask walls for permission to lay a parallel wall
                    //                                  if ( b->GetWall() && wal && !wal->RunsParallel( b->GetWall() ) )
                    //                                          return start;
                    //                                  if ( b->other->GetWall() && wal && !wal->RunsParallel( b->other->GetWall() ) )
                    //                                          return start;

                    // ask edge if it is splittalbe
                    if ( !b->Splittable() )
                        return start;

                    // create endpoint
                    ePoint*    D=tNEW(ePoint(end));
#ifdef DEBUG
                    Check();
#endif
                    // delete faces inside quad ABCE and connect A...E with new
                    // ePoint D.

                    tControlledPTR< eFace > oldFace_b = ZombifyFace( b->Face());
                    tControlledPTR< eFace > oldFace_bOther = ZombifyFace( b->other->Face() );

                    eHalfEdge *DC, *DA;
                    b->Split( DC, DA, D );
                    KillEdge(b);
                    DC = DC->other;

                    tASSERT( DC->Point() == D );
                    tASSERT( DA->Point() == D );
                    tASSERT( DC->other->Point() == C );
                    tASSERT( DA->other->Point() == A );

                    eHalfEdge *DE=tNEW(eHalfEdge) (D,E);
                    eHalfEdge *DB=tNEW(eHalfEdge) (D,B);
                    DA->other->SetWall(toBePlaced.Wall());

                    AddFaceAll(tNEW(eFace) (DE,e2,DA->other, oldFace_bOther ) );
                    AddFaceAll(tNEW(eFace) (DC,e1,DE->other, oldFace_bOther ) );
                    AddFaceAll(tNEW(eFace) (DB,a ,DC->other, oldFace_b ) );
                    AddFaceAll(tNEW(eFace) (DA,c ,DB->other, oldFace_b ) );

#ifdef DEBUG
                    Check();
#endif
                    return D;
                }
            }
            // finnished!
        }


        else{
            // some definitions and trivial tests:

            eHalfEdge* c = currentEdge;
            eHalfEdge* e = rightFromCurrent;
            eHalfEdge* d = leftFromCurrent;

            eFace  *F = c->Face();
            ePoint *C = c->Point();

            if (*C == end){
#ifdef DEBUG
                Check();
#endif
                return C;
            }
            //      eHalfEdge *dummy=NULL;


            ePoint *D = d->Point();

            if (*D == end){
                d->other->SetWall(toBePlaced.Wall());

#ifdef DEBUG
                Check();
#endif
                return D;
            }

            ePoint *B= e->Point();

            if (*B == end){
                c->SetWall(toBePlaced.Wall());

#ifdef DEBUG
                Check();
#endif
                return B;
            }

            // if dir is parallel with eEdge c:

            /*
              if(exactly_onLeft){
              todo->Split(d,dummy);
              delete todo;
              todo=dummy;
              start=todo->p[0];
              restart=1;
              }
               
              else
            */
            {
                if (!e->other || !e->other->Face())
                {
                    // tERR_ERROR_INT ("Left Grid!");
                    // z-man: no need for an error! We can go on!
                    // nevertheless, should you get here in the debugger, I would
                    // ask you to follow the rest of this code block carefully
                    // and send me a trace ( which lines were visited, which pointers
                    // were set ) of it.
                    st_Breakpoint();

                    // grid rift or outer rim?
                    bool rift = false;

                    if ( !e->other )
                    {
                        // all gridded edges have other correctly set. Even the outer ones.
                        rift = true;
                    }

                    // get the wall of the halfopen edge
                    eWall* wall = e->GetWall();
                    if ( !wall && e->other )
                        wall = e->other->GetWall();

                    // no wall or splittable wall? This is not the outer edge, it is a rift.
                    if ( !wall || wall->Splittable() )
                        rift = true;

                    // wall is useless when e is not complete; forgt about it.
                    if ( !e->other )
                        wall = 0;

                    if ( rift )
                    {
                        // a rift! topology police to the rescue ( after eliminating
                        // the witnesses, of course )!
                        toBePlaced.Wall()->SplitByActive( wall );
                        return start;
                    }
                    else
                    {
                        // line to be drawn hit the outer edge.
                        // should not happen either; Range() should have prevented it.
                        // grow one step anyway:
                        Grow();

                        // test again
                        if (!e->other || !e->other->Face())
                        {
                            // still no luck? a case for the topology police.
                            toBePlaced.Wall()->SplitByActive( 0 );
                            return start;
                        }
                    }
                    // z-man: Thanks for debugging, this is all I need.
                }

                {
                    eFace  *G=e->other->Face();

                    eHalfEdge* b = e->other->next;
                    eHalfEdge* a = b->next;
                    tASSERT(a->next == e->other);

                    ePoint *A = a->Point();

                    /* we have the following Situation:

                    Should this figure get distorted, align the ":"

                    :         A
                    :         #
                    :        # ##
                    :   a   #  [eFace G]
                    :      #       ##
                    :     #       X  ##  b
                    :    #   e   /     ## 
                    : D ########/######### B
                    :   #      /(new eWall)
                    :   #     /      #
                    :   #    /  [eFace F]
                    :   #   /    #
                    : d #  /   # c 
                    :   # /  #
                    :   #/ #
                    :   ##   
                    :   C
                            
                    */


                    eCoord dd=*C-*D;
                    eCoord aa=*A-*D;
                    eCoord bb=*A-*B;
                    eCoord cc=*C-*B;

                    REAL scale = aa.NormSquared() + bb.NormSquared() +
                                 bb.NormSquared() + cc.NormSquared();

                    tASSERT(scale > 0);
                    //tASSERT(aa.NormSquared() > scale *SMALL_FLOAT);
                    //tASSERT(bb.NormSquared() > scale *SMALL_FLOAT);
                    //tASSERT(dd.NormSquared() > scale *SMALL_FLOAT);
                    //tASSERT(cc.NormSquared() > scale *SMALL_FLOAT);

#ifdef DEBUG
                    Check();
#endif

                    if (change_grid && e->Movable() && aa*dd>scale*.0001 && cc*bb >scale*.0001){
                        /*

                        if the angles CDA and ABC are less than 180deg, we can 
                        just "turn" eEdge e:


                        :         A
                        :[eFace F]#
                        :        #|##  [eFace G]
                        :   a   # |  ## b
                        :      # |     ##
                        :     #  |       ##
                        :    #  |    X     ## 
                        : D #   |   |        # B
                        :   #  |   |(new eWall)
                        :   #  e  |      #
                        :   # |  |     #
                        :   # | |    #
                        : d #| |   # c 
                        :   #||  #
                        :   #| #
                        :   ##   
                        :   C

                        */
                        if (*A == *C)
                        {
                            start = A;
                            restart = 1;
                            continue;
                        }


                        tControlledPTR< eFace > oldF = ZombifyFace(F);
                        tControlledPTR< eFace > oldG = ZombifyFace(G);
                        KillEdge(e);

                        e=tNEW(eHalfEdge) (C,A);
                        F=tNEW(eFace)     (a,d,e, oldF, oldG);
                        G=tNEW(eFace)     (b,e->other,c, oldF, oldG);

                        AddFaceAll(F);
                        AddFaceAll(G);

                        eCoord ee=*A-*C;
                        REAL x_test=ee*dir;
                        if (x_test>=0){
                            exactly_onLeft=(x_test<=EPS * EPS * se_EstimatedRangeOfMult(ee,dir));
                            currentEdge = c;
                            tASSERT(currentEdge->ID >= 0);
                        }
                        else{
                            exactly_onLeft=-1;
                            currentEdge = e;
                            tASSERT(currentEdge->ID >= 0);
                        }

#ifdef DEBUG
                        Check();
#endif

                    }

                    /* if not, we hace to introduce a new ePoint E: the cut between our
                       new eWall and eEdge e.

                            
                       :        A
                       :        ##
                       :        #\##
                       :         # \###
                       :         #  \  ##
                       : [eFace G]#  \   ## [eFace GG]
                       :          #   \    ###
                       :           #   aa     ##
                       :       a   #     \      ## b
                       :            #     \       ### 
                       :            #      \   CC    ##
                       :             #      \ /        ## 
                       :           D ## dd ##E### bb #### B [BD = e]
                       :            #      /(new eWall)
                       : [eFace F] #     /      #
                       :          #   cc     # [eFace FF]
                       :         #   /    #
                       :      d #  /   # c 
                       :       # /  #
                       :      #/ #
                       :     #/#   
                       :    ##
                       :   C
                            

                    */

                    else{
                        // calculate the coordinates of the intersection ePoint E:
                        ePoint *E;
                        eHalfEdge *bb,*cc,*dd;

                        if (*C == *A)
                        {
                            start = A;
                            restart = 1;
                            continue;
                        }

                        REAL ar = .5f;

                        {
                            eHalfEdge *newtodo;
                            ePoint *CC = tNEW(ePoint(end));
                            tStackObject< eTempEdge > todo (C, CC);
                            E=tNEW(ePoint) (e->IntersectWithCareless(todo.Edge(0)));

                            ar = e->Ratio(*E);

                            //        REAL br = todo.Edge(0)->Ratio(*E);
                            //        tASSERT(-.1f < ar && ar < 1.1f);
                            //        tASSERT(-.1f < br && br < 1.1f);


                            tASSERT(E->NormSquared() < se_maxGridSize*100);
                            todo.Edge(0)->Split(cc,newtodo,E);
                            KillEdge(newtodo);  // not needed. Make sure it gets deleted.
                        }

                        if (toBePlaced.Wall())
                        {
#ifdef DEBUG
                            tASSERT(toBePlaced.Wall()->Splittable());
                            Check();
#endif

                            // inform walls about the reason of their split
                            if ( !e->Movable() )
                            {
                                eWall *other = e->GetWall();
                                if ( other )
                                {
                                    toBePlaced.Wall()->SplitByActive( other );
                                }
                                other = e->other->GetWall();
                                if ( other )
                                {
                                    toBePlaced.Wall()->SplitByActive( other );
                                }
                            }

                            eWall *wa, *wb;
                            toBePlaced.Wall()->Split(wa, wb, eCoord::V(*start, *E, end));

                            // place the first bit of wall
                            cc->SetWall(wa);

                            // modify the temp edge to be placed to represent the rest of the wall
                            toBePlaced.SetWall( wb );
                            toBePlaced.Coord(0) = *E;
                        }

                        REAL arreal = ar;
                        if (ar > .99999f)
                            ar = .99999f;
                        if (ar < .00001f)
                            ar = .00001f;
                        *E = *B + (*D - *B) * ar;

                        if (*E == *D || (arreal >= 1.0f && !d->other->GetWall()))
                        {
                            d->other->SetWall(cc->GetWall());
                            KillEdge(cc);
                            start = D;
                            restart = 1;
                            continue;
                        }

                        if (*E == *B || (arreal <= 0.0f && !c->GetWall()))
                        {
                            c->SetWall(cc->GetWall());

                            KillEdge(cc);
                            start = B;
                            restart = 1;
                            continue;
                        }



                        e->other->Split(dd,bb,E);

                        F->CorrectArea();
                        G->CorrectArea();
                        tControlledPTR< eFace > oldF = ZombifyFace(F);
                        tControlledPTR< eFace > oldG = ZombifyFace(G);
                        KillEdge(e);


                        start = E;

                        bool aeq = false, ceq = false;

                        if (*A == *E)
                        {
                            if (A==leakPoint)
                                st_Breakpoint();

                            A->Replace(E);
                            KillPoint(A);

                            a->other->SetWall(dd->GetWall());
                            a->SetWall(dd->other->GetWall());
                            b->SetWall(bb->other->GetWall());
                            b->other->SetWall(bb->GetWall());
                            KillEdge(dd);
                            KillEdge(bb);
                            dd = a->other;
                            bb = b->other;
                            aeq = true;

                            se_LinkFaces( oldG, oldF );
                        }

                        if (*C == *E)
                        {
                            tASSERT(!aeq);

                            C->Replace(E);
                            KillPoint(C);

                            d->other->SetWall(dd->other->GetWall());
                            d->SetWall(dd->GetWall());
                            c->other->SetWall(bb->other->GetWall());
                            c->SetWall(bb->GetWall());

                            KillEdge(dd);
                            KillEdge(bb);
                            KillEdge(cc);
                            dd = d;
                            bb = c;
                            ceq = true;

                            se_LinkFaces( oldF, oldG );
                        }

                        if (!ceq)
                        {
                            F=tNEW(eFace) (d,cc,dd->other, oldF );
                            eFace *FF=tNEW(eFace) (c,bb->other,cc->other, oldF );

                            AddFaceAll(F);
                            AddFaceAll(FF);
                        }

                        eHalfEdge *aa=NULL;


                        if (!aeq)
                        {
                            aa = tNEW(eHalfEdge) (E,A);

                            eFace *GG=tNEW(eFace) (b,aa->other,bb, oldG );
                            G=tNEW(eFace) (a,dd,aa, oldG );
                            AddFaceAll(G);
                            AddFaceAll(GG);
                        }
                        else
                        {
                            start = E;
                            restart = true;
                            continue;
                        }

#ifdef DEBUG
                        Check();
#endif
                        if (end == *E)
                            return E;

                        //          start = E;
                        eCoord ea=*A-*E;
                        dir   = end - *E;
                        REAL x_test=ea*dir;

                        tASSERT (aa);
                        if (x_test>=0){
                            currentEdge=bb;
                            tASSERT(currentEdge->ID >= 0);
                            exactly_onLeft=(x_test<=EPS*EPS*se_EstimatedRangeOfMult(ea,dir));
                            // if (exactly_onLeft) std::cerr << "Achtung 3!\n";
                        }

                        else{
                            currentEdge=aa;
                            tASSERT(currentEdge->ID >= 0);
                            exactly_onLeft=-1;
                        }
                    }
                }
            }
        }
    }

    tERR_ERROR_INT("We shound never get here!");
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const tList<eCamera>& eGrid::Cameras

(

)

const [inline]

Definition at line 150 of file eGrid.h.

References cameras.

Referenced by fill_audio(), and RenderAllViewports().

{return cameras;}

Here is the caller graph for this function:

const tList<eGameObject>& eGrid::GameObjects

(

)

const [inline]

Definition at line 151 of file eGrid.h.

References gameObjects.

Referenced by gGame::Analysis(), gBaseZoneHack::CheckSurvivor(), gBaseZoneHack::CountZonesOfTeam(), cWidget::Map::DrawObjects(), gAIPlayer::EmergencySurvive(), gGame::StateUpdate(), gAIPlayer::Think(), gAIPlayer::ThinkSurvive(), gAIPlayer::ThinkTrace(), and gBaseZoneHack::Timestep().

{return gameObjects;}

Here is the caller graph for this function:

const tList<eGameObject>& eGrid::GameObjectsInteresting

(

)

const [inline]

Definition at line 152 of file eGrid.h.

References gameObjectsInteresting.

{return gameObjectsInteresting;}

const tList<eGameObject>& eGrid::GameObjectsInactive

(

)

const [inline]

Definition at line 153 of file eGrid.h.

References gameObjectsInactive.

{return gameObjectsInactive;}

int eGrid::NumberOfCameras

(

)

Definition at line 193 of file eDisplay.cpp.

References cameras, and GrowingArrayBase::Len().

{return cameras.Len();}

Here is the call graph for this function:

const eCoord & eGrid::CameraPos

(

int

i

)

Definition at line 194 of file eDisplay.cpp.

References cameras.

Referenced by display_simple(), and draw_eWall().

{return cameras(i)->CameraPos();}

Here is the caller graph for this function:

eCoord eGrid::CameraGlancePos

(

int

i

)

Definition at line 195 of file eDisplay.cpp.

References cameras.

Referenced by display_simple().

{return cameras(i)->CameraGlancePos();}

Here is the caller graph for this function:

const eCoord & eGrid::CameraDir

(

int

i

)

Definition at line 196 of file eDisplay.cpp.

References cameras.

Referenced by display_simple(), draw_eWall(), and paint_sr_lowerSky().

{return cameras(i)->CameraDir();}

Here is the caller graph for this function:

REAL eGrid::CameraHeight

(

int

i

)

Definition at line 197 of file eDisplay.cpp.

References cameras.

Referenced by Render().

{return cameras(i)->CameraZ();}

Here is the caller graph for this function:

void eGrid::AddGameObjectInteresting

(

eGameObject *

o

)

Definition at line 2620 of file eGrid.cpp.

References tList< T, MALLOC, REFERENCE >::Add(), gameObjectsInteresting, and eGameObject::interestingID.

                                                      {
    gameObjectsInteresting.Add(o, o->interestingID);
}

Here is the call graph for this function:

void eGrid::RemoveGameObjectInteresting

(

eGameObject *

o

)

Definition at line 2624 of file eGrid.cpp.

References gameObjectsInteresting, eGameObject::interestingID, and tList< T, MALLOC, REFERENCE >::Remove().

                                                      {
    gameObjectsInteresting.Remove(o, o->interestingID);
}

Here is the call graph for this function:

void eGrid::AddGameObjectInactive

(

eGameObject *

o

)

Definition at line 2628 of file eGrid.cpp.

References tList< T, MALLOC, REFERENCE >::Add(), gameObjectsInactive, and eGameObject::inactiveID.

                                                      {
    gameObjectsInactive.Add(o, o->inactiveID);
}

Here is the call graph for this function:

void eGrid::RemoveGameObjectInactive

(

eGameObject *

o

)

Definition at line 2632 of file eGrid.cpp.

References gameObjectsInactive, eGameObject::inactiveID, and tList< T, MALLOC, REFERENCE >::Remove().

                                                      {
    gameObjectsInactive.Remove(o, o->inactiveID);
}

Here is the call graph for this function:

typedef void eGrid::WallProcessor

(

eWall *

w

)

void eGrid::ProcessWallsInRange	(	WallProcessor *	proc,
		const eCoord &	pos,
		REAL	range,
		eFace *	startFace
	)

Definition at line 2764 of file eGrid.cpp.

References eCoord, eWall::Edge(), edges, eHalfEdge::Face(), FindSurroundingFace(), GrowingArrayBase::Len(), eFace::nextProcessed, NULL, eHalfEdge::Other(), eHalfEdge::Point(), ProcessWallsRecursive(), REAL, st_Breakpoint(), tASSERT, eHalfEdge::Vec(), and wallsNotYetInserted.

{
    int i;

    start = FindSurroundingFace( pos, start );
    if ( !start )
        return;

    s_rangeSquared = range * range;
    s_start = start;
    s_processed = start;

    // process the gridded walls
    ProcessWallsRecursive( proc, pos, range, start, NULL, 100 );

#ifdef DEBUG_OLD
    // make sure all walls were processed

    // process the not gridded walls
    for ( i = edges.Len()-1; i>=0; --i )
    {
        const eHalfEdge *leave = edges(i);

        if ( !leave->Other() || !leave->Face() || !leave->Other()->Face() )
            continue;

        eCoord normal = leave->Vec().Conj();
        REAL normalLen = normal.Norm();
        if ( normalLen <= 0 )
            continue;
        normal *= 1/ normalLen;

        eCoord Pos1 = normal.Turn( *leave->Point() - pos );
        eCoord Pos2 = normal.Turn( *leave->Other()->Point() - pos );

        tASSERT( fabs( Pos1.y - Pos2.y ) <= fabs( Pos1.y + Pos2.y +.1f ) * .1f );

        // start test: the line through the edge "leave" must come closer than "range" to "pos"
        if ( Pos1.y < range && Pos1.y > -range )
        {
            // check for real hit
            if ( Pos1.x * Pos2.x < 0 ||
                    Pos1.NormSquared() < s_rangeSquared ||
                    Pos2.NormSquared() < s_rangeSquared )
            {
                if ( !leave->Face()->nextProcessed || !leave->Other()->Face()->nextProcessed )
                {
                    st_Breakpoint();
                }

                if ( leave->Face()->nextProcessed &&  !leave->Other()->Face()->nextProcessed )
                {
                    while ( s_processed != start )
                    {
                        eFace* next = s_processed->nextProcessed;
                        s_processed->nextProcessed = NULL;
                        s_processed = next;
                    }

                    start->nextProcessed = NULL;
                    s_processed = leave->Face();
                    leave->Face()->nextProcessed = start;

                    st_Breakpoint();

                    ProcessWallsRecursive( proc, pos, range, leave->Face(), NULL, 100 );

                    while ( s_processed != start )
                    {
                        eFace* next = s_processed->nextProcessed;
                        s_processed->nextProcessed = NULL;
                        s_processed = next;
                    }

                    start->nextProcessed = NULL;
                    s_processed = NULL;

                }
            }
        }
    }
#endif

    while ( s_processed && s_processed != start )
    {
        eFace* next = s_processed->nextProcessed;
        s_processed->nextProcessed = NULL;
        s_processed = next;
    }

    start->nextProcessed = NULL;
    s_processed = NULL;

    // process the not gridded walls
    for ( i = wallsNotYetInserted.Len()-1; i>=0; --i )
    {
        eWall* w= wallsNotYetInserted(i);
        const eHalfEdge *leave = w->Edge();

        eCoord normal = leave->Vec().Conj();
        REAL normalLen = normal.Norm();
        if ( normalLen <= 0 )
            continue;
        normal *= 1/ normalLen;

        eCoord Pos1 = normal.Turn( *leave->Point() - pos );
        eCoord Pos2 = normal.Turn( *leave->Other()->Point() - pos );

        tASSERT( fabs( Pos1.y - Pos2.y ) <= fabs( Pos1.y + Pos2.y +.1f ) * .1f );

        // start test: the line through the edge "leave" must come closer than "range" to "pos"
        if ( Pos1.y < range && Pos1.y > -range )
        {
            // check for real hit
            if ( Pos1.x * Pos2.x < 0 ||
                    Pos1.NormSquared() < s_rangeSquared ||
                    Pos2.NormSquared() < s_rangeSquared )
            {
                (*proc) ( w );
            }
        }

    }
}

Here is the call graph for this function:

void eGrid::display_simple	(	int	viewer,
		bool	floor,
		bool	sr_upperSky,
		bool	sr_lowerSky,
		REAL	flooralpha,
		bool	eWalls,
		bool	gameObjects,
		REAL &	zNear
	)			[protected]

Definition at line 294 of file eDisplay.cpp.

References BeginLines(), CameraDir(), CameraGlancePos(), CameraPos(), cameras, eCoord, edges, EXTENSION, eHalfEdge::Face(), tReferencable< T, MUTEX >::GetRefcount(), infinity_xy_plane(), INTENSITY, GrowingArrayBase::Len(), lower_height, ModelMatrix(), eHalfEdge::other, paint_sr_lowerSky(), eHalfEdge::Point(), points, REAL, eDebugLine::Render(), eGameObject::RenderAll(), eWallRim::RenderAll(), RenderEnd(), rFLOOR_GRID, rFLOOR_OFF, rFLOOR_TEXTURE, rFLOOR_TWOTEXTURE, se_BlackSky(), se_glFloorColor(), se_glFloorTexture(), se_glFloorTexture_a(), se_glFloorTexture_b(), se_GridSize(), SIDELEN, sr_alphaBlend, sr_CheckGLError(), sr_DepthOffset(), sr_floorDetail, sr_highRim, su_FetchAndStoreSDLInput(), TexMatrix(), upper_height, x, and z.

Referenced by Render().

                                        {
    sr_CheckGLError();

    /*
    static GLfloat S[]={1,0,0,0};
    static GLfloat T[]={0,1,0,0};
    static GLfloat R[]={0,0,1,0};
    static GLfloat Q[]={0,0,0,1};

    glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
    glTexGenfv(GL_S,GL_OBJECT_PLANE,S);

    glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
    glTexGenfv(GL_T,GL_OBJECT_PLANE,T);

    glTexGeni(GL_R,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
    glTexGenfv(GL_R,GL_OBJECT_PLANE,R);

    glTexGeni(GL_Q,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
    glTexGenfv(GL_Q,GL_OBJECT_PLANE,Q);

    glDisable(GL_TEXTURE_GEN_T);
    glDisable(GL_TEXTURE_GEN_S);
    glDisable(GL_TEXTURE_GEN_R);
    glDisable(GL_TEXTURE_GEN_Q);
    */


    glDisable(GL_DEPTH_TEST);
    glDepthMask(GL_FALSE);

    glDisable(GL_CULL_FACE);

    eCoord camPos = CameraGlancePos( viewer );
    // eWallRim::Bound( camPos, 10 );

    if (sr_upperSky || se_BlackSky()){
        if (se_BlackSky()){
            //glDisable(GL_TEXTURE);
            glDisable(GL_TEXTURE_2D);

            glColor3f(0,0,0);

            if ( z < lower_height )
                infinity_xy_plane(camPos, this->CameraDir(viewer),lower_height);

            glEnable(GL_TEXTURE_2D);
        }
        else {
            TexMatrix();
            glLoadIdentity();
            //      glScalef(.25,.25,.25);

            se_glFloorTexture();

            glColor3f(.5,.5,1);

            if ( z < upper_height )
                infinity_xy_plane(camPos, this->CameraDir(viewer),upper_height);
        }
    }

    if (sr_lowerSky && !sr_highRim){
        paint_sr_lowerSky(this, viewer,sr_upperSky, camPos);
    }

    if (floor){
        sr_DepthOffset(false);

        su_FetchAndStoreSDLInput();
        int floorDetail = sr_floorDetail;

        // no multitexturing without alpha blending
        if ( !sr_alphaBlend && floorDetail > rFLOOR_TEXTURE )
            floorDetail = rFLOOR_TEXTURE;

        switch(floorDetail){
        case rFLOOR_OFF:
            break;
        case rFLOOR_GRID:
            {
        #define SIDELEN   (se_GridSize())
        #define EXTENSION 10

                eCoord center = CameraPos(viewer) + CameraDir(viewer) * (SIDELEN * EXTENSION * .8);

                REAL x=center.x;
                REAL y=center.y;
                int xn=static_cast<int>(x/SIDELEN);
                int yn=static_cast<int>(y/SIDELEN);


                //glDisable(GL_TEXTURE);
                glDisable(GL_TEXTURE_2D);

        #define INTENSITY(x,xx) (1-(((x)-(xx))*((x)-(xx))/(EXTENSION*SIDELEN*EXTENSION*SIDELEN)))


                BeginLines();
                for(int i=xn-EXTENSION;i<=xn+EXTENSION;i++){
                    REAL intens=INTENSITY(i*SIDELEN,x);
                    if (intens<0) intens=0;
                    se_glFloorColor(intens,intens);
                    glVertex2f(i*SIDELEN,y-SIDELEN*(EXTENSION+1));
                    glVertex2f(i*SIDELEN,y+SIDELEN*(EXTENSION+1));
                }
                for(int j=yn-EXTENSION;j<=yn+EXTENSION;j++){
                    REAL intens=INTENSITY(j*SIDELEN,y);
                    if (intens<0) intens=0;
                    se_glFloorColor(intens,intens);
                    glVertex2f(x-(EXTENSION+1)*SIDELEN,j*SIDELEN);
                    glVertex2f(x+(EXTENSION+1)*SIDELEN,j*SIDELEN);
                }
                RenderEnd();
            }
            break;

        case rFLOOR_TEXTURE:
            TexMatrix();
            glLoadIdentity();
            glScalef(1/se_GridSize(),1/se_GridSize(),1.);

            se_glFloorTexture();
            se_glFloorColor(flooralpha);

            infinity_xy_plane( camPos, CameraDir(viewer) );

            /* old way: draw every triangle
            for(int i=eFace::faces.Len()-1;i>=0;i--){
            eFace *f=eFace::faces(i);

            if (f->visHeight[viewer]<z){
            glBegin(GL_TRIANGLES);
            for(int j=0;j<=2;j++){
            glVertex3f(f->p[j]->x,f->p[j]->y,0);
            }
            glEnd();
            }
            }
            */

            break;

        case rFLOOR_TWOTEXTURE:
            se_glFloorColor(flooralpha);

            TexMatrix();
            glLoadIdentity();
            REAL gs = 1/se_GridSize();
            glScalef(0.01*gs,gs,1.);

            se_glFloorTexture_a();
            infinity_xy_plane( camPos, CameraDir(viewer) );

            se_glFloorColor(flooralpha);

            TexMatrix();
            glLoadIdentity();
            glScalef(gs,.01*gs,1.);

            se_glFloorTexture_b();

            glDepthFunc(GL_LEQUAL);
            glBlendFunc(GL_SRC_ALPHA,GL_ONE);
            infinity_xy_plane( camPos, CameraDir(viewer) );
            glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

            break;
        }
    }

    glEnable(GL_DEPTH_TEST);
    glDepthMask(GL_TRUE);

    TexMatrix();
    glLoadIdentity();
    ModelMatrix();

    //  glDisable(GL_TEXTURE_GEN_S);
    //  glDisable(GL_TEXTURE_GEN_T);
    //  glDisable(GL_TEXTURE_GEN_Q);
    //  glDisable(GL_TEXTURE_GEN_R);

    if(eWalls){
        {
            su_FetchAndStoreSDLInput();
    
            eWallRim::RenderAll( cameras(viewer) );
        }

        if (sr_lowerSky && sr_highRim){
            //      glEnable(GL_TEXTURE_GEN_S);
            //      glEnable(GL_TEXTURE_GEN_T);
            //      glEnable(GL_TEXTURE_GEN_Q);
            //      glEnable(GL_TEXTURE_GEN_R);

            paint_sr_lowerSky(this, viewer,sr_upperSky, camPos);

            //      glDisable(GL_TEXTURE_GEN_S);
            //      glDisable(GL_TEXTURE_GEN_T);
            //      glDisable(GL_TEXTURE_GEN_Q);
            //      glDisable(GL_TEXTURE_GEN_R);

            TexMatrix();
            glLoadIdentity();
            ModelMatrix();
        }
    }

    sr_CheckGLError();

    if (eWalls){
        // glDisable(GL_CULL_FACE);
        // draw_eWall(this,viewer,0,zNear,cameras(viewer));

        /*
        #ifdef DEBUG
        for(int i=sg_netPlayerWalls.Len()-1;i>=0;i--){
          glMatrixMode(GL_MODELVIEW);
          glPushMatrix();
          if (sg_netPlayerWalls(i)->Preliminary())
        glTranslatef(0,0,4);
          else
        glTranslatef(0,0,8);
          if (sg_netPlayerWalls(i)->Wall())
        sg_netPlayerWalls(i)->Wall()->RenderList(false);
          glPopMatrix();
          }
        #endif
        */

        /*
        static int oldlen=0;
        int newlen=sg_netPlayerWalls.Len();
        if (newlen!=oldlen){
          con << "Number of player eWalls now " << newlen << '\n';
          oldlen=newlen;
        }
        */

    }

    sr_CheckGLError();

    if (gameObjects)
        eGameObject::RenderAll(this, cameras(viewer));

    eDebugLine::Render();
#ifdef DEBUG

    ePath::RenderLast();

    if (debug_grid){
        //glDisable(GL_TEXTURE);
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_LIGHTING);
        BeginLines();

        int i;
        for(i=edges.Len()-1;i>=0;i--){
            eHalfEdge *e=edges[i];
            if (e->Face())
                glColor4f(1,1,1,1);
            else
                glColor4f(0,0,1,1);

            glVertex3f(e->Point()->x,e->Point()->y,10);
            glVertex3f(e->Point()->x,e->Point()->y,15);
            glVertex3f(e->Point()->x,e->Point()->y,.1);
            glVertex3f(e->other->Point()->x,e->other->Point()->y,.1);
            glVertex3f(e->other->Point()->x,e->other->Point()->y,10);
            glVertex3f(e->other->Point()->x,e->other->Point()->y,15);

        }

        for(i=points.Len()-1;i>=0;i--){
            ePoint *p=points[i];
            glColor4f(1,0,0,1);
            glVertex3f(p->x,p->y,0);
            glVertex3f(p->x,p->y,(p->GetRefcount()+1)*5);
        }
        /*
        for(int i=sg_netPlayerWalls.Len()-1;i>=0;i--){
          eEdge *e=sg_netPlayerWalls[i]->Edge();
        glColor4f(0,1,0,1);

          glVertex3f(e->Point()->x,e->Point()->y,5);
          glVertex3f(e->Point()->x,e->Point()->y,10);
          glVertex3f(e->Point()->x,e->Point()->y,10);
          glVertex3f(e->other->Point()->x,e->other->Point()->y,10);
          glVertex3f(e->other->Point()->x,e->other->Point()->y,10);
          glVertex3f(e->other->Point()->x,e->other->Point()->y,5);
        }
        */
        RenderEnd();
    }
#endif

}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::AddFace

(

eFace *

f

)

[protected]

Definition at line 2370 of file eGrid.cpp.

References tList< T, MALLOC, REFERENCE >::Add(), eFace::CorrectArea(), faces, eDual::ID, and requestCleanup.

Referenced by AddFaceAll().

{
    if (f->ID >= 0)
        return;

    faces.Add(f, f->ID);

    if (f->CorrectArea())
        requestCleanup = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::RemoveFace

(

eFace *

f

)

[protected]

Definition at line 2381 of file eGrid.cpp.

References faces, eDual::ID, and tList< T, MALLOC, REFERENCE >::Remove().

Referenced by Clear(), KillFace(), and ZombifyFace().

{
    if (f->ID < 0)
        return;

    faces.Remove(f, f->ID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::AddEdge

(

eHalfEdge *

e

)

[protected]

Definition at line 2389 of file eGrid.cpp.

References tList< T, MALLOC, REFERENCE >::Add(), tRecorderSync< DATA >::Archive(), edges, eHalfEdge::ID, eHalfEdge::Other(), eHalfEdge::Point(), and tASSERT.

Referenced by AddFaceAll().

{
    if (e->ID >= 0)
        return;

    tASSERT(e->Other() && *e->Point() != *e->Other()->Point());

    edges.Add(e, e->ID);

    int idrec = e->ID;
    tRecorderSync< int >::Archive( "_GRID_ADD_EDGE", 8, idrec );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::RemoveEdge

(

eHalfEdge *

e

)

[protected]

Definition at line 2402 of file eGrid.cpp.

References tRecorderSync< DATA >::Archive(), edges, eHalfEdge::ID, tList< T, MALLOC, REFERENCE >::Remove(), and st_Breakpoint().

Referenced by Clear(), and KillEdge().

{
    if (e == leakEdge)
        st_Breakpoint();

    if (e->ID < 0)
        return;

    int idrec = e->ID;
    tRecorderSync< int >::Archive( "_GRID_REMOVE_EDGE", 8, idrec );

    edges.Remove(e, e->ID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::AddPoint

(

ePoint *

p

)

[protected]

Definition at line 2416 of file eGrid.cpp.

References tList< T, MALLOC, REFERENCE >::Add(), eCoord, eDual::ID, and points.

Referenced by AddFaceAll().

{
    if (p->ID >= 0)
        return;

    points.Add(p, p->ID);

#ifdef DEBUG_DISTORT
    // debug facility: distort grid
    static eCoord distortion(1,0);
    distortion = distortion.Turn(.6,.8);
    *p = *p + distortion;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::RemovePoint

(

ePoint *

p

)

[protected]

Definition at line 2431 of file eGrid.cpp.

References eDual::ID, points, tList< T, MALLOC, REFERENCE >::Remove(), and st_Breakpoint().

Referenced by Clear(), and KillPoint().

{
    if (p == leakPoint)
        st_Breakpoint();

    if (p->ID < 0)
        return;

    points.Remove(p, p->ID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::KillFace

(

eFace *

f

)

[protected]

Definition at line 2442 of file eGrid.cpp.

References RemoveFace(), and eFace::Unlink().

{
    tControlledPTR< eFace > keep( f );
    RemoveFace(f);
    f->Unlink();
}

Here is the call graph for this function:

void eGrid::KillEdge

(

eHalfEdge *

e

)

[protected]

Definition at line 2457 of file eGrid.cpp.

References eHalfEdge::other, RemoveEdge(), and eHalfEdge::Unlink().

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

{
    tControlledPTR< eHalfEdge > keep( e );
    RemoveEdge(e);
    tControlledPTR< eHalfEdge > o ( e->other );

    e->Unlink();

    if (o)
    {
        KillEdge(o);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::KillPoint

(

ePoint *

p

)

[protected]

Definition at line 2471 of file eGrid.cpp.

References RemovePoint(), and ePoint::Unlink().

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

{
    tControlledPTR< ePoint > keep( p );
    RemovePoint(p);
    p->Unlink();
}

Here is the call graph for this function:

Here is the caller graph for this function:

tControlledPTR< eFace > eGrid::ZombifyFace

(

eFace *

f

)

[protected]

Definition at line 2449 of file eGrid.cpp.

References RemoveFace(), and eFace::Unlink().

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

{
    tControlledPTR< eFace > keep( f );
    RemoveFace(f);
    f->Unlink();
    return keep;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eGrid::AddFaceAll

(

eFace *

f

)

[protected]

Definition at line 2478 of file eGrid.cpp.

References AddEdge(), AddFace(), AddPoint(), eDual::edge, eHalfEdge::next, eHalfEdge::other, eHalfEdge::Point(), and tASSERT.

Referenced by Create(), DrawLine(), and Grow().

{
    eHalfEdge *run = f->edge;
    for(int j=0;j<=2;j++){
        AddEdge(run);
        AddEdge(run->other);
        AddPoint(run->Point());
        run = run->next;
    }
    tASSERT (run == f->edge);

    AddFace(f);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Friends And Related Function Documentation

friend class eCamera [friend]

Definition at line 77 of file eGrid.h.

friend class eFace [friend]

Definition at line 78 of file eGrid.h.

friend class eHalfEdge [friend]

Definition at line 79 of file eGrid.h.

friend class ePoint [friend]

Definition at line 80 of file eGrid.h.

Referenced by DrawLine().

friend class eGameObject [friend]

Definition at line 81 of file eGrid.h.

friend class eWall [friend]

Definition at line 82 of file eGrid.h.

Referenced by Create(), and Grow().

friend class tReferencable< eGrid > [friend]

Definition at line 83 of file eGrid.h.

---

Member Data Documentation

eAxis eGrid::axis [protected]

Definition at line 87 of file eGrid.h.

Referenced by DirectionWinding(), GetDirection(), SetWinding(), Turn(), and WindingNumber().

bool eGrid::requestCleanup [protected]

Definition at line 208 of file eGrid.h.

Referenced by AddFace(), Create(), DrawLine(), and SimplifyAll().

tJUST_CONTROLLED_PTR< ePoint > eGrid::A [protected]

Definition at line 211 of file eGrid.h.

tJUST_CONTROLLED_PTR< ePoint > eGrid::B [protected]

Definition at line 211 of file eGrid.h.

tJUST_CONTROLLED_PTR< ePoint > eGrid::C [protected]

Definition at line 211 of file eGrid.h.

tJUST_CONTROLLED_PTR< eHalfEdge > eGrid::a [protected]

Definition at line 212 of file eGrid.h.

tJUST_CONTROLLED_PTR< eHalfEdge > eGrid::b [protected]

Definition at line 212 of file eGrid.h.

tJUST_CONTROLLED_PTR< eHalfEdge > eGrid::c [protected]

Definition at line 212 of file eGrid.h.

Referenced by Check(), Clear(), Create(), DrawLine(), and Grow().

REAL eGrid::maxNormSquared [protected]

Definition at line 213 of file eGrid.h.

Referenced by Clear(), Create(), Grow(), and Range().

eCoord eGrid::base [protected]

Definition at line 214 of file eGrid.h.

tList<eHalfEdge, false, true> eGrid::edges [protected]

Definition at line 217 of file eGrid.h.

Referenced by AddEdge(), Check(), Clear(), display_simple(), ProcessWallsInRange(), RemoveEdge(), SimplifyAll(), and SimplifyNum().

tList<ePoint, false, true> eGrid::points [protected]

Definition at line 218 of file eGrid.h.

Referenced by AddPoint(), Check(), Clear(), display_simple(), and RemovePoint().

tList<eFace, false, true> eGrid::faces [protected]

Definition at line 219 of file eGrid.h.

Referenced by AddFace(), Check(), Clear(), FindSurroundingFace(), RemoveFace(), and SimplifyAll().

tList<eGameObject> eGrid::gameObjects [protected]

Definition at line 222 of file eGrid.h.

Referenced by eGameObject::DeleteAll(), GameObjects(), eGameObject::RenderAll(), and eGameObject::s_Timestep().

tList<eGameObject> eGrid::gameObjectsInactive [protected]

Definition at line 223 of file eGrid.h.

Referenced by AddGameObjectInactive(), GameObjectsInactive(), and RemoveGameObjectInactive().

tList<eGameObject> eGrid::gameObjectsInteresting [protected]

Definition at line 224 of file eGrid.h.

Referenced by AddGameObjectInteresting(), GameObjectsInteresting(), and RemoveGameObjectInteresting().

tList<eCamera> eGrid::cameras [protected]

Definition at line 227 of file eGrid.h.

Referenced by CameraDir(), CameraGlancePos(), CameraHeight(), CameraPos(), Cameras(), display_simple(), NumberOfCameras(), and eCamera::s_Timestep().

tList<eWall> eGrid::wallsNotYetInserted [protected]

Definition at line 231 of file eGrid.h.

Referenced by eHalfEdge::CrossesNewWall(), and ProcessWallsInRange().

---

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

• src/engine/eGrid.h
• src/engine/eDisplay.cpp
• src/engine/eGrid.cpp

---