C4FoWBeam Class Reference

#include <C4FoWBeam.h>

Public Member Functions
	C4FoWBeam (int32_t iLeftX, int32_t iLeftY, int32_t iRightX, int32_t iRightY)
bool	isDirty () const
bool	isClean () const
C4FoWBeam *	getNext () const
void	setNext (C4FoWBeam *next)
int32_t	getLeftX (int32_t y) const
int32_t	getRightX (int32_t y) const
float	getLeftXf (int32_t y) const
float	getRightXf (int32_t y) const
int32_t	getLeftEndY () const
int32_t	getLeftEndX () const
float	getLeftEndXf () const
int32_t	getRightEndY () const
int32_t	getRightEndX () const
float	getRightEndXf () const
StdStrBuf	getDesc () const
bool	isLeft (int32_t x, int32_t y) const
bool	isRight (int32_t x, int32_t y) const
bool	isInside (int32_t x, int32_t y) const
void	SetLeft (int32_t x, int32_t y)
void	SetRight (int32_t x, int32_t y)
bool	MergeRight (int32_t x, int32_t y)
bool	MergeLeft (int32_t x, int32_t y)
C4FoWBeam *	Split (int32_t x, int32_t y)
bool	EliminateRight (int32_t x, int32_t y)
void	MergeDirty ()
void	Clean (int32_t y)
void	Dirty (int32_t y)
void	Prune (int32_t y)
void	CompileFunc (StdCompiler *pComp)

Detailed Description

This class represents one beam. A beam is a triangle spanned by two rays: one going from the origin to the left delimiter point, one going from the origin to the right delimiter point.

LeftEndX/Y and RightEndX/Y are the positions where this beam hit a solid material pixel while LeftX/Y and RightX/Y are the positions at which this beam did not hit but merely streaked a solid pixel (= the neighboring beam hits it) and thus continues until *EndX/Y.

It is assumed that the beam always goes down in display coordinate system, thus the Y-position of the delimiting points is always > 0. C4FoWLightSection transforms the coordinate system after calculation to implement the beams that go into other directions. This class here always assumes one direction.

A beam is initially marked as "dirty", meaning that the end points of the beam haven't been found yet (by the ray trace algorithm) and the beam will extend further. When all beams are "clean", the algorithm is done.

Definition at line 37 of file C4FoWBeam.h.

Constructor & Destructor Documentation

C4FoWBeam()

C4FoWBeam::C4FoWBeam ( int32_t  iLeftX, int32_t  iLeftY, int32_t  iRightX, int32_t  iRightY  )

inline

Definition at line 40 of file C4FoWBeam.h.

        : iLeftX(iLeftX), iLeftY(iLeftY), iRightX(iRightX), iRightY(iRightY),
          iLeftEndY(0), iRightEndY(0),
          iError(0),
          fDirty(true),
          pNext(nullptr)
    { }

Referenced by Split().

Here is the caller graph for this function:

Member Function Documentation

Clean()

void C4FoWBeam::Clean

(

int32_t

y

)

Set a new end point, making the beam "clean".

Definition at line 157 of file C4FoWBeam.cpp.

{
    // Search hit something, this beam is now clean.
    iLeftEndY = y;
    iRightEndY = y;
    fDirty = false;
}

Referenced by Prune(), and C4FoWLightSection::Update().

Here is the caller graph for this function:

CompileFunc()

void C4FoWBeam::CompileFunc

(

StdCompiler *

pComp

)

Definition at line 188 of file C4FoWBeam.cpp.

{
    pComp->Value(mkNamingAdapt(iLeftX, "iLeftX"));
    pComp->Value(mkNamingAdapt(iLeftY, "iLeftY"));
    pComp->Value(mkNamingAdapt(iRightX, "iRightX"));
    pComp->Value(mkNamingAdapt(iRightY, "iRightY"));
    pComp->Value(mkNamingAdapt(iLeftEndY, "iLeftEndY"));
    pComp->Value(mkNamingAdapt(iRightEndY, "iRightEndY"));
    pComp->Value(mkNamingAdapt(iError, "iError"));
    pComp->Value(mkNamingAdapt(fDirty, "fDirty"));
}

References mkNamingAdapt(), and StdCompiler::Value().

Here is the call graph for this function:

Dirty()

void C4FoWBeam::Dirty

(

int32_t

y

)

Extend this beam to the new maximum length, making it "dirty" because now the end points haven't been found anymore Called when the size of the light has been increased to the given value.

Definition at line 165 of file C4FoWBeam.cpp.

{
    // Got invalidated, beam is dirty until updated
    iLeftEndY = y;
    iRightEndY = y;
    fDirty = true;
}

Referenced by C4FoWLightSection::Invalidate(), MergeDirty(), Split(), and C4FoWLightSection::Update().

Here is the caller graph for this function:

EliminateRight()

bool C4FoWBeam::EliminateRight	(	int32_t	x,
		int32_t	y
	)

Makes this beam span from its left delimiter point to the right delimiter point of the next but one beam, removing the two beams in between in the process. In other words, removes the next beam and merges this beam with the next but one beam. Returns false and does not do the action in case the error threshold would be reached.

Definition at line 90 of file C4FoWBeam.cpp.

{
    // Called on the beams left of the one getting eliminated
    C4FoWBeam *pElim = pNext, *pMerge = pNext->pNext;
    assert(!!pElim); assert(!!pMerge);
    assert(!isDirty()); assert(!pMerge->isDirty());
 
    // Calc errors, add those accumulated on both merged beams
    int32_t iErr = getDoubleTriangleSurface(
        getLeftEndX(), getLeftEndY(),
        pMerge->getRightEndX(), pMerge->getRightEndY(),
        x, y);
    iErr += pMerge->iError;
    if (iError + iErr > C4FoWMergeThreshold)
        return false;
 
    // Do elimination
    iRightX = pMerge->iRightX;
    iRightY = pMerge->iRightY;
    iRightEndY = pMerge->iRightEndY;
    pNext = pMerge->pNext;
    iError += iErr;
    delete pElim;
    delete pMerge;
    return true;
}

References isDirty().

Referenced by C4FoWLightSection::Update().

Here is the call graph for this function:

Here is the caller graph for this function:

getDesc()

StdStrBuf C4FoWBeam::getDesc

(

)

const

Definition at line 36 of file C4FoWBeam.cpp.

                                   {
    return FormatString("%d:%d@%d:%d%s",
        getLeftX(1000),
        getRightX(1000),
        getLeftEndY(),
        getRightEndY(),
        fDirty ? "*" : "");
}

References FormatString(), getLeftEndY(), getLeftX(), getRightEndY(), and getRightX().

Referenced by C4FoWLightSection::Update().

Here is the call graph for this function:

Here is the caller graph for this function:

getLeftEndX()

int32_t C4FoWBeam::getLeftEndX ( ) const

inline

Definition at line 69 of file C4FoWBeam.h.

{ return getLeftX(iLeftEndY); }

References getLeftX().

Here is the call graph for this function:

getLeftEndXf()

float C4FoWBeam::getLeftEndXf ( ) const

inline

Definition at line 70 of file C4FoWBeam.h.

{ return getLeftXf(iLeftEndY); }

References getLeftXf().

Referenced by C4FoWLightSection::CalculateTriangles().

Here is the call graph for this function:

Here is the caller graph for this function:

getLeftEndY()

int32_t C4FoWBeam::getLeftEndY ( ) const

inline

Definition at line 68 of file C4FoWBeam.h.

{ return iLeftEndY; }

Referenced by C4FoWLightSection::CalculateTriangles(), getDesc(), C4FoWLightSection::Invalidate(), MergeDirty(), and C4FoWLightSection::Update().

Here is the caller graph for this function:

getLeftX()

int32_t C4FoWBeam::getLeftX ( int32_t  y ) const

inline

Definition at line 63 of file C4FoWBeam.h.

{ return iLeftX * y / iLeftY; }

Referenced by getDesc(), getLeftEndX(), and C4FoWLightSection::Update().

Here is the caller graph for this function:

getLeftXf()

float C4FoWBeam::getLeftXf ( int32_t  y ) const

inline

Definition at line 65 of file C4FoWBeam.h.

{ return (iLeftX * y) / float(iLeftY); }

Referenced by getLeftEndXf().

Here is the caller graph for this function:

getNext()

C4FoWBeam* C4FoWBeam::getNext ( ) const

inline

Definition at line 59 of file C4FoWBeam.h.

{ return pNext; }

Referenced by C4FoWLightSection::CalculateTriangles(), C4FoWLightSection::CompileFunc(), C4FoWLightSection::Dirty(), C4FoWLightSection::Invalidate(), MergeDirty(), C4FoWLightSection::Prune(), and C4FoWLightSection::Update().

Here is the caller graph for this function:

getRightEndX()

int32_t C4FoWBeam::getRightEndX ( ) const

inline

Definition at line 72 of file C4FoWBeam.h.

{ return getRightX(iRightEndY); }

References getRightX().

Referenced by C4FoWLightSection::Update().

Here is the call graph for this function:

Here is the caller graph for this function:

getRightEndXf()

float C4FoWBeam::getRightEndXf ( ) const

inline

Definition at line 73 of file C4FoWBeam.h.

{ return getRightXf(iRightEndY); }

References getRightXf().

Referenced by C4FoWLightSection::CalculateTriangles().

Here is the call graph for this function:

Here is the caller graph for this function:

getRightEndY()

int32_t C4FoWBeam::getRightEndY ( ) const

inline

Definition at line 71 of file C4FoWBeam.h.

{ return iRightEndY; }

Referenced by C4FoWLightSection::CalculateTriangles(), getDesc(), C4FoWLightSection::Invalidate(), and C4FoWLightSection::Update().

Here is the caller graph for this function:

getRightX()

int32_t C4FoWBeam::getRightX ( int32_t  y ) const

inline

Definition at line 64 of file C4FoWBeam.h.

{ return iRightX * y / iRightY; }

Referenced by getDesc(), getRightEndX(), and C4FoWLightSection::Update().

Here is the caller graph for this function:

getRightXf()

float C4FoWBeam::getRightXf ( int32_t  y ) const

inline

Definition at line 66 of file C4FoWBeam.h.

{ return (iRightX * y) / float(iRightY); }

Referenced by getRightEndXf().

Here is the caller graph for this function:

isClean()

bool C4FoWBeam::isClean ( ) const

inline

Definition at line 58 of file C4FoWBeam.h.

{ return !fDirty; }

isDirty()

bool C4FoWBeam::isDirty ( ) const

inline

Definition at line 57 of file C4FoWBeam.h.

{ return fDirty; }

Referenced by EliminateRight(), C4FoWLightSection::Invalidate(), MergeDirty(), MergeLeft(), MergeRight(), Split(), and C4FoWLightSection::Update().

Here is the caller graph for this function:

isInside()

bool C4FoWBeam::isInside ( int32_t  x, int32_t  y  ) const

inline

returns whether the given point is inside the triangle that is defined by this beam

Definition at line 88 of file C4FoWBeam.h.

                                              {
        return !isLeft(x, y) && !isRight(x, y);
    }

References isLeft(), and isRight().

Referenced by Split().

Here is the call graph for this function:

Here is the caller graph for this function:

isLeft()

bool C4FoWBeam::isLeft ( int32_t  x, int32_t  y  ) const

inline

returns whether the given point is left of an imaginery line drawn from the origin to the left delimiter point (point is left of beam)

Definition at line 78 of file C4FoWBeam.h.

                                            {
        return iLeftX * y > x * iLeftY;
    }

Referenced by C4FoWLightSection::Invalidate(), isInside(), MergeLeft(), and C4FoWLightSection::Update().

Here is the caller graph for this function:

isRight()

bool C4FoWBeam::isRight ( int32_t  x, int32_t  y  ) const

inline

returns whether the given point is right of an imaginery line drawn from the origin to the right delimiter point (point is right of beam)

Definition at line 83 of file C4FoWBeam.h.

                                             {
        return iRightX * y < x * iRightY;
    }

Referenced by isInside(), MergeRight(), and C4FoWLightSection::Update().

Here is the caller graph for this function:

MergeDirty()

void C4FoWBeam::MergeDirty

(

)

Definition at line 136 of file C4FoWBeam.cpp.

{
    // As a rule, dirty beams following each other should
    // always be merged, so splits can be reverted once
    // the landscape changes.
    C4FoWBeam *pWith = pNext;
    assert(isDirty()); assert(!!pWith); assert(pWith->isDirty());
 
    // Figure out how far the new dirty beams reaches. Note that
    // we might lose information about the landscape here.
    Dirty(std::min(getLeftEndY(), pWith->getLeftEndY()));
 
    // Set right
    iRightX = pWith->iRightX;
    iRightY = pWith->iRightY;
 
    // Relink & delete
    pNext = pWith->getNext();
    delete pWith;
}

References Dirty(), getLeftEndY(), getNext(), and isDirty().

Referenced by C4FoWLightSection::Invalidate().

Here is the call graph for this function:

Here is the caller graph for this function:

MergeLeft()

bool C4FoWBeam::MergeLeft	(	int32_t	x,
		int32_t	y
	)

Set the new left delimiter point to the given point if the resulting difference in size is less than the error threshold. If successfull, adds the introduced error to iError.

Asserts that the given point is really left of the right delimiter point

Definition at line 70 of file C4FoWBeam.cpp.

{
    assert(!isDirty()); assert(isLeft(x, y));
 
    // Calculate error.
    float iErr = getDoubleTriangleSurface(
        getLeftEndX(), iLeftEndY,
        getRightEndX(), iRightEndY,
        x, y);
    if (iError + iErr > C4FoWMergeThreshold)
        return false;
 
    // Move left endpoint.
    iLeftX = x;
    iLeftY = y;
    iLeftEndY = y;
    iError += iErr;
    return true;
}

References isDirty(), and isLeft().

Referenced by C4FoWLightSection::Update().

Here is the call graph for this function:

Here is the caller graph for this function:

MergeRight()

bool C4FoWBeam::MergeRight	(	int32_t	x,
		int32_t	y
	)

Set the new right delimiter point to the given point if the resulting difference in size is less than the error threshold. If successfull, adds the introduced error to iError.

Asserts that the given point is really right of the right delimiter point

Definition at line 45 of file C4FoWBeam.cpp.

{
    // Note: Right-merging is the most common and most important optimization.
    // This procedure will probably be *hammered* as a result. Worth inlining?
 
    assert(!isDirty()); assert(isRight(x, y));
 
    // Calculate error. Note that simply summing up errors is not correct,
    // strictly speaking (as new and old error surfaces might overlap). Still,
    // this is quite elaborate already, no need to make it even more
    int32_t iErr = getDoubleTriangleSurface(
        getLeftEndX(), iLeftEndY,
        getRightEndX(), iRightEndY,
        x, y);
    if (iError + iErr > C4FoWMergeThreshold)
        return false;
 
    // Move right endpoint.
    iRightX = x;
    iRightY = y;
    iRightEndY = y;
    iError += iErr;
    return true;
}

References isDirty(), and isRight().

Referenced by C4FoWLightSection::Update().

Here is the call graph for this function:

Here is the caller graph for this function:

Prune()

void C4FoWBeam::Prune

(

int32_t

y

)

Prune this beam to a new maximum length. Called when the size of the light has been decreased to the given value.

Definition at line 173 of file C4FoWBeam.cpp.

{
    // Check which sides we need to prune
    bool fLeft = (iLeftEndY >= y),
         fRight = (iRightEndY >= y);
    // If both sides got pruned, we are clean
    // (can't possibly extend this beam further)
    if (fLeft && fRight)
        Clean(y);
    else if (fLeft)
        iLeftEndY = y;
    if (fRight)
        iRightEndY = y;
}

References Clean().

Here is the call graph for this function:

SetLeft()

void C4FoWBeam::SetLeft ( int32_t  x, int32_t  y  )

inline

Definition at line 92 of file C4FoWBeam.h.

{ iLeftX = x; iLeftY = y; }

Referenced by C4FoWLightSection::Update().

Here is the caller graph for this function:

setNext()

void C4FoWBeam::setNext ( C4FoWBeam *  next )

inline

Definition at line 60 of file C4FoWBeam.h.

{ pNext=next; }

Referenced by C4FoWLightSection::CompileFunc().

Here is the caller graph for this function:

SetRight()

void C4FoWBeam::SetRight ( int32_t  x, int32_t  y  )

inline

Definition at line 93 of file C4FoWBeam.h.

{ iRightX = x; iRightY = y; }

Referenced by C4FoWLightSection::Update().

Here is the caller graph for this function:

Split()

C4FoWBeam * C4FoWBeam::Split	(	int32_t	x,
		int32_t	y
	)

Split this beam into two: this beam and the returned one. The given point x,y is the position at which the two resulting beams are connected with their left/right endpoints. It is asserted that the given point is inside the previous beam. (So the beam can only made smaller)

Definition at line 117 of file C4FoWBeam.cpp.

{
    // Make sure to never create negative-surface beams
    assert(isDirty()); assert(isInside(x, y));
 
    // Allocate a new beam. Ugh, expensive.
    C4FoWBeam *pBeam = new C4FoWBeam(x, y, iRightX, iRightY);
    pBeam->Dirty(iLeftEndY);
 
    // Move to make space
    iRightX = x;
    iRightY = y;
 
    // Relink
    pBeam->pNext = pNext;
    pNext = pBeam;
    return pBeam;
}

References C4FoWBeam(), Dirty(), isDirty(), and isInside().

Referenced by C4FoWLightSection::Update().

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• C4FoWBeam.h
• C4FoWBeam.cpp