src/engine/eGrid.cpp File Reference

#include "eGrid.h"
#include "eTess2.h"
#include "rTexture.h"
#include "tEventQueue.h"
#include "eTimer.h"
#include "eWall.h"
#include "eGameObject.h"
#include "eCamera.h"
#include "tMath.h"
#include "nConfig.h"
#include "tRecorder.h"
#include <vector>
#include <set>

Include dependency graph for eGrid.cpp:

Go to the source code of this file.

Classes
class	eReplacementStorage
struct	eFaceReplacementArgument
Defines
#define	SMALL_FLOAT   1E-30
#define	SIMPLIFY
Typedefs
typedef std::vector < tJUST_CONTROLLED_PTR< eFace > >	eReplacementStorageBase
typedef std::pair< eFace *, REAL >	eFaceScorePair
typedef std::set< const eFace * >	eFaceVisitedSet
Functions
	tDEFINE_REFOBJ (ePoint) tDEFINE_REFOBJ(eHalfEdge) tDEFINE_REFOBJ(eFace) REAL se_EstimatedRangeOfMult(const eCoord &a
void	se_LinkFaces (tControlledPTR< eFace > &old, eFace *replacement)
eFaceScorePair	se_FindBestReplacement (const eFace *old, eFaceReplacementArgument &arg)
bool	Movable (const ePoint *p)
void	ClampMovement (const ePoint *p, eCoord &dir, const eHalfEdge *e)
void	ClampMovement (const ePoint *p, eCoord &dir)
const eCoord	se_zeroCoord (0, 0)
static void	ProcessWallsRecursive (eGrid::WallProcessor *proc, const eCoord &pos, REAL range, eFace *start, eFace *from, int depthLeft)
Variables
const REAL	se_maxGridSize = 1E+15
int	se_debugExt = 0
static int	se_simplifyEdges = 0
static const int	se_simplifyEdgesSuccess = 20
static const int	se_simplifyEdgesNew = 2
static nSettingItem< short >	se_bugRipNet ("BUG_RIP", se_bugRip)
static eHalfEdge *	leakEdge = NULL
static ePoint *	leakPoint = NULL
static int	se_drawLineTimeout = 10000
static tSettingItem< int >	se_drawLineTimeoutConf ("DRAWLINE_TIMEOUT", se_drawLineTimeout)
eGrid *	currentGrid = NULL
static REAL	s_rangeSquared
static eFace *	s_start = NULL
static eFace *	s_processed = NULL

---

Define Documentation

#define SIMPLIFY

Definition at line 1664 of file eGrid.cpp.

#define SMALL_FLOAT   1E-30

Definition at line 50 of file eGrid.cpp.

---

Typedef Documentation

typedef std::pair< eFace*, REAL > eFaceScorePair

Definition at line 349 of file eGrid.cpp.

typedef std::set< const eFace* > eFaceVisitedSet

Definition at line 350 of file eGrid.cpp.

typedef std::vector< tJUST_CONTROLLED_PTR<eFace> > eReplacementStorageBase

Definition at line 331 of file eGrid.cpp.

---

Function Documentation

void ClampMovement	(	const ePoint *	p,
		eCoord &	dir
	)

Definition at line 1732 of file eGrid.cpp.

References ClampMovement(), eDual::Edge(), eHalfEdge::Next(), and eHalfEdge::Other().

{
    eHalfEdge* run = p->Edge();
    eHalfEdge* stop =run;

    // run through all edges from this point
    do
    {
        // get the max mobility of the edge
        ClampMovement( p, dir, run );

        // advance to next edge from this point
        run = run->Other();
        if ( run )
            run = run->Next();
    }
    while ( run && stop != run );
}

Here is the call graph for this function:

void ClampMovement	(	const ePoint *	p,
		eCoord &	dir,
		const eHalfEdge *	e
	)

Definition at line 1694 of file eGrid.cpp.

References eCoord, eHalfEdge::Next(), eHalfEdge::next, REAL, tASSERT, and eHalfEdge::Vec().

Referenced by ClampMovement(), and eFace::CorrectArea().

{
    eHalfEdge* next = e->Next();
    // get two of the side vectors of the face
    eCoord oppositeEdge = next->Vec();
    eCoord adjacentEdge = e->Vec();

    // calculate current surface area
    REAL area = oppositeEdge * adjacentEdge;

    // calculate the influence of the proposed movement on the surface area
    REAL areaChange = dir * oppositeEdge;

    // allow it if the change increases the area
    if ( areaChange >= 0 )
        return;

    // allow it if the change keeps the area positive
    if ( area + areaChange >= 0 )
        return;

    // if the current surface area is already negative, forbid the change
    if ( area < 0 )
    {
        dir = eCoord(0,0);
        return;
    }

    // clamp the desired movement
    REAL clampFactor = - area / areaChange;
    tASSERT( clampFactor >=0 && clampFactor <= 1 );

    // clamp
    dir = dir * clampFactor;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Movable

(

const ePoint *

p

)

Definition at line 1668 of file eGrid.cpp.

References eDual::Edge(), eHalfEdge::Movable(), eHalfEdge::Next(), and eHalfEdge::Other().

Referenced by eFace::CorrectArea().

{
    eHalfEdge* run = p->Edge();
    eHalfEdge* stop =run;

    // run through all edges from this point
    do
    {
        // one of the edges contains a wall, abort:
        if ( !run->Movable() )
            return false;

        // advance to next edge from this point
        run = run->Other();
        if ( run )
            run = run->Next();
    }
    while ( run && stop != run );

    // no obstacles found.
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void ProcessWallsRecursive	(	eGrid::WallProcessor *	proc,
		const eCoord &	pos,
		REAL	range,
		eFace *	start,
		eFace *	from,
		int	depthLeft
	)			[static]

Definition at line 2703 of file eGrid.cpp.

References eCoord, eDual::Edge(), eHalfEdge::Face(), eWallHolder::GetWall(), eHalfEdge::Next(), eFace::nextProcessed, NULL, eHalfEdge::Other(), eHalfEdge::Point(), REAL, tASSERT, and eHalfEdge::Vec().

Referenced by eGrid::ProcessWallsInRange().

{
    tASSERT( start );

    if ( depthLeft < 0 )
        return;

    if ( start->nextProcessed )
        return;

    start->nextProcessed = s_processed;
    s_processed = start;


    eHalfEdge* leave = start->Edge();
    for ( int i = 2; i>=0; --i )
    {
        if ( leave->Other() && leave->Other()->Face() )
        {
            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 ) + fabs ( Pos2.y ) + .1f * .1f );

            // start test: the line through the edge "leave" must come closer than "range" to "pos"
            // and we have to be on the correct side
            if ( Pos1.y > -range && Pos1.y <= range*.01f )
            {
                // check for real hit
                if ( Pos1.x * Pos2.x < 0 ||
                        Pos1.NormSquared() < s_rangeSquared ||
                        Pos2.NormSquared() < s_rangeSquared )
                {
                    // recurse
                    if ( NULL == leave->Other()->Face()->nextProcessed )
                        ProcessWallsRecursive( proc, pos, range, leave->Other()->Face(), start , depthLeft - 1 );

                    // process this wall
                    if ( leave->GetWall() )
                        (*proc) ( leave->GetWall() );
                    if ( leave->Other()->GetWall() )
                        (*proc) ( leave->Other()->GetWall() );
                }
            }
        }
        leave = leave->Next();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

eFaceScorePair se_FindBestReplacement	(	const eFace *	old,
		eFaceReplacementArgument &	arg
	)

Definition at line 358 of file eGrid.cpp.

References eFaceReplacementArgument::coord, eFaceReplacementArgument::direction, eFace::GetReplacementStorage(), eFace::Insideness(), eDual::IsInGrid(), eFaceReplacementArgument::lastDirection, se_maxGridSize, and eFaceReplacementArgument::visited.

Referenced by eFace::FindReplacement().

{
    // return invalid return if the face was already visited
    if ( arg.visited.find( old ) != arg.visited.end() )
        return eFaceScorePair( 0, -se_maxGridSize );

    // register face as visited
    arg.visited.insert( old );

    // find entry in replacement map

    {
        // real work starts here
        // get the vector of replacements
        const eReplacementStorage& storage = old->GetReplacementStorage();

        // iterate it

        // the currently best face/insideness pair
        std::pair< eFace*, REAL > best( 0, -100000 );
        for( eReplacementStorage::const_iterator i = storage.begin(); i != storage.end(); ++i )
        {
            // the current face/insideness pair
            eFaceScorePair current; // ( 0, -100000 );

            // the current face
            eFace* face = *i;

            // is it inside the grid?
            if ( face->IsInGrid() )
            {
                // enter it directly
                current.first = face;
                current.second = face->Insideness( arg.coord, arg.direction, arg.lastDirection );
            }
            else
            {
                // no, we have to look for a replacement recursively
                current = se_FindBestReplacement( face, arg );
            }

            if ( current.second > best.second && current.first )
                best = current;
        }

        return best;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void se_LinkFaces	(	tControlledPTR< eFace > &	old,
		eFace *	replacement
	)

Definition at line 336 of file eGrid.cpp.

References tASSERT.

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

{
    tASSERT( old != replacement );

    // we only need to store an eFace if it is referenced by something different than
    // the pointer we got it by
    if ( old->GetRefcount() > 1 )
    {
        eReplacementStorage& storage = old->GetReplacementStorage();
        storage.push_back( replacement );
    }
}

Here is the caller graph for this function:

const eCoord se_zeroCoord	(	0	,
		0
	)

tDEFINE_REFOBJ

(

ePoint

)

const

---

Variable Documentation

eGrid* currentGrid = NULL

Definition at line 2067 of file eGrid.cpp.

eHalfEdge* leakEdge = NULL [static]

Definition at line 714 of file eGrid.cpp.

ePoint* leakPoint = NULL [static]

Definition at line 715 of file eGrid.cpp.

eFace* s_processed = NULL [static]

Definition at line 2700 of file eGrid.cpp.

REAL s_rangeSquared [static]

Definition at line 2698 of file eGrid.cpp.

eFace* s_start = NULL [static]

Definition at line 2699 of file eGrid.cpp.

nSettingItem<short> se_bugRipNet("BUG_RIP", se_bugRip) [static]

int se_debugExt = 0

Definition at line 55 of file eGrid.cpp.

int se_drawLineTimeout = 10000 [static]

Definition at line 717 of file eGrid.cpp.

tSettingItem<int> se_drawLineTimeoutConf("DRAWLINE_TIMEOUT", se_drawLineTimeout) [static]

const REAL se_maxGridSize = 1E+15

Definition at line 51 of file eGrid.cpp.

Referenced by eFace::Create(), eGrid::DrawLine(), eGrid::Grow(), eGrid::Range(), and se_FindBestReplacement().

int se_simplifyEdges = 0 [static]

Definition at line 58 of file eGrid.cpp.

Referenced by eGrid::DrawLine(), eGrid::SimplifyAll(), and eGrid::SimplifyNum().

const int se_simplifyEdgesNew = 2 [static]

Definition at line 65 of file eGrid.cpp.

Referenced by eGrid::DrawLine().

const int se_simplifyEdgesSuccess = 20 [static]

Definition at line 62 of file eGrid.cpp.

Referenced by eGrid::SimplifyNum().

---