gWallRim Class Reference

#include <gWall.h>

Inheritance diagram for gWallRim:

[legend]

Collaboration diagram for gWallRim:

[legend]

List of all members.

Public Member Functions
	gWallRim (eGrid *grid, REAL h=10000)
	gWallRim (eGrid *grid, REAL tBeg, REAL tEnd, REAL h=10000)
virtual	~gWallRim ()
virtual bool	Splittable () const
virtual void	Split (eWall *&w1, eWall *&w2, REAL a)
virtual bool	RunsParallelPassive (eWall *newWall)
void	RenderReal (const eCamera *cam)
Protected Member Functions
virtual void	OnBlocksCamera (eCamera *cam, REAL height) const
	called by the camera code when this wall is between the cycle and the camera
virtual REAL	Height ()
virtual REAL	SeeHeight ()
Private Attributes
REAL	renderHeight_
	the height with which this wall is really rendered
REAL	lastUpdate_
	time of the last render height update
REAL	tBeg_
REAL	tEnd_
	begin and end texture coordinates

---

Detailed Description

Definition at line 45 of file gWall.h.

---

Constructor & Destructor Documentation

gWallRim::gWallRim	(	eGrid *	grid,
		REAL	h = 10000
	)

Definition at line 125 of file gWall.cpp.

Referenced by Split().

        :eWallRim(grid, false, h), renderHeight_(h), lastUpdate_(-100), tBeg_( 0 ), tEnd_( 0 )
{
    // std::cout << "create " << this << "\n";
}

Here is the caller graph for this function:

gWallRim::gWallRim	(	eGrid *	grid,
		REAL	tBeg,
		REAL	tEnd,
		REAL	h = 10000
	)

Definition at line 131 of file gWall.cpp.

        :eWallRim(grid, false, h), renderHeight_(h), lastUpdate_(-100), tBeg_( tBeg ), tEnd_( tEnd )
{
    // std::cout << "create " << this << "\n";
}

gWallRim::~gWallRim

(

)

[virtual]

Definition at line 137 of file gWall.cpp.

{
    // std::cout << "destroy " << this << "\n";
}

---

Member Function Documentation

bool gWallRim::Splittable

(

)

const [virtual]

Reimplemented from eWallRim.

Definition at line 142 of file gWall.cpp.

{return 1;}

void gWallRim::Split	(	eWall *&	w1,
		eWall *&	w2,
		REAL	a
	)			[virtual]

Reimplemented from eWall.

Definition at line 143 of file gWall.cpp.

References eWall::grid, gWallRim(), eWallRim::height, REAL, tBeg_, tEnd_, and tNEW.

{
    // std::cout << "split " << this << "\n";

    REAL tMid = tEnd_ * ratio + tBeg_ * ( 1 - ratio );
    w1=tNEW(gWallRim(grid, tBeg_, tMid, height));
    w2=tNEW(gWallRim(grid, tMid, tEnd_, height));
}

Here is the call graph for this function:

bool gWallRim::RunsParallelPassive

(

eWall *

newWall

)

[virtual]

Reimplemented from eWall.

Definition at line 153 of file gWall.cpp.

{
    return false;
}

void gWallRim::RenderReal

(

const eCamera *

cam

)

[virtual]

Implements eWallRim.

Definition at line 255 of file gWall.cpp.

References abs(), BeginQuads(), eCamera::CameraDir(), eCamera::CameraGlancePos(), eCamera::CameraZ(), eCamera::CenterCamDir(), eCamera::CenterPos(), Color(), eWallRim::DestroyDisplayList(), eCoord, eWall::Edge(), eWall::EndPoint(), EPS, gWallRim_helper(), eWallRim::height, lastUpdate_, pos, REAL, RenderEnd(), renderHeight_, se_mainGameTimer, sg_arenaWallShadowDist, sg_arenaWallShadowNear, sg_arenaWallShadowSideDist, sg_arenaWallShadowSize, sg_bugTransparency, sg_bugTransparencyDemand, sg_MoviePack(), sg_MPRimStretchX, sg_MPRimStretchY, sg_RimStretchX, sg_RimStretchY, sw, Swap(), tBeg_, tEnd_, eTimer::Time(), ts, and Vertex().

                                           {
    if ( Edge() ){
        const eCoord *p1=&EndPoint(0);
        const eCoord *p2=&EndPoint(1);

        REAL X_SCALE=sg_RimStretchX;
        REAL Z_SCALE=sg_RimStretchY;

        // determine height and transparency
        bool transparency = sg_bugTransparency || ( sg_bugTransparencyDemand && renderHeight_ < height );
        REAL h = transparency ? height : renderHeight_;
        if ( transparency )
            glDisable( GL_DEPTH_TEST );

      if (sg_MoviePack()){
            X_SCALE=sg_MPRimStretchX;
            Z_SCALE=sg_MPRimStretchY;
        }

        if ( tBeg_ == tEnd_ )
        {
            tBeg_=(p1->x+p1->y);
            tEnd_=(p2->x+p2->y);
        }
        REAL tBeg = tBeg_/X_SCALE;
        REAL tEnd = tEnd_/X_SCALE;
        eCoord P1=*p1;
        eCoord P2=*p2;

        // draw "shadow" away from camera
        if ( cam )
        {
            // determine relevant position
            eCoord pos = cam->CenterPos();

            // alternative that does not look so good
            // eCoord pos = cam->CameraGlancePos();

            // calculate normal on wall
            eCoord normal = (P1 - P2).Turn(0,1);
            normal.Normalize();

            // determine distance of the position to the wall's line
            REAL side = -eCoord::F(normal, pos - P1);

            // length scale
            REAL scale = pos.Norm() + 10 + (P1-P2).Norm();

            // add a tiny contribution from the direction to avoid side==zero
            // side += (  20 * EPS * eCoord::F( normal, cam->CenterCamDir() )
            //          +10 * EPS * eCoord::F( normal, cam->CameraDir() ) ) * scale;

            // fallback to camera position in case of doubt
            // if ( fabs(side) < EPS*scale )
            //    side = -eCoord::F( normal, cam->CameraGlancePos() );

            // get absolute value and sign of side
            REAL abs = fabs(side);
            REAL sign = side/abs;

            // if abs is low, override the sign by considering the direction
            if ( abs < EPS*scale*10 )
            {
                // the direction object and camera are facing
                eCoord facing = cam->CenterCamDir() * 2 + cam->CameraDir();

                sign = eCoord::F( normal, facing );
                abs  = fabs( sign );
                if ( abs > EPS )
                {
                    sign/= fabs( sign );
                    abs  = EPS*scale;
                }
                else
                {
                    abs  = 0;
                    sign = 0;
                }
            }

            // driving direction
            eCoord dir = cam->CenterCamDir();

            // the side the camera is on
            REAL camSide = -eCoord::F(normal, cam->CameraGlancePos() - P1);

            // no shadow if camera and vehicle are on different sides
            if ( camSide * sign < -EPS*scale )
                sign = 0;

            // if the camera is closer to the wall than the vehicle, take the abs value from that
            if ( sign * eCoord::F( normal, dir ) > -EPS )
            {
                if ( camSide * sign >= 0 )
                {
                    REAL camAbs = fabs( camSide );
                    if ( camAbs < abs )
                        abs = camAbs;
                }
                else
                {
                    // wall lies between camera and cycle
                    abs = 0;
                }
            }

            // add scaled down distance of the wall and the projected path
            {
                REAL d1 = dir * (pos - P1);
                REAL d2 = dir * (pos - P2);
                if ( d1 * d2 >= 0 )
                {
                    REAL dist = fabs( d1 );
                    d2 = fabs( d2 );
                    if ( d2 < dist )
                        dist = d2;

                    abs += dist * sg_arenaWallShadowSideDist/sg_arenaWallShadowDist;
                }
            }

            // add scaled down distance along the wall's direction
            /*
            {
                REAL a1 = -(pos - P1)*normal;
                REAL a2 =  (pos - P2)*normal;
                if (a1 > 0)
                    abs += a1 * sg_arenaWallShadowSideDist/sg_arenaWallShadowDist;
                if (a2 > 0)
                    abs += a2 * sg_arenaWallShadowSideDist/sg_arenaWallShadowDist;
            }
            */

            if ( sign != 0 && abs < sg_arenaWallShadowSideDist )
            {
                // determine height scale
                REAL heightForShadow = cam->CameraZ()+10;
                if ( this->renderHeight_*4 < heightForShadow )
                    heightForShadow = this->renderHeight_*4;

                // determine shadow extension
                REAL extension = heightForShadow*sg_arenaWallShadowSize * sign/( 1 + abs/sg_arenaWallShadowNear );
                extension *= ( 1 - abs/sg_arenaWallShadowSideDist );

                // get two more vertices for teh shadow
                eCoord P3=P1+normal*extension;
                eCoord P4=P2+normal*extension;

                // render shadow
                Color(0,0,0);
                BeginQuads();
                Vertex(P1.x, P1.y, 0);
                Vertex(P2.x, P2.y, 0);
                Vertex(P4.x, P4.y, 0);
                Vertex(P3.x, P3.y, 0);
            }
        }

        {
            eCoord vec = P1-P2;
            REAL xs = vec.x*vec.x;
            REAL ys = vec.y*vec.y;
            REAL intensity = .7 + .3 * xs/(xs+ys);
            RenderEnd( true );
            Color(intensity, intensity, intensity);
        }

        if (sg_MoviePack()){
            bool sw=false;

            if (tBeg>tEnd){
                Swap(P1,P2);
                Swap(tBeg,tEnd);
                //sw=true;
            }

            REAL ta=tBeg;
            eCoord ca=P1;
            for (int i=int(ceil(tBeg));i<tEnd;i++){
                eCoord cb=P1+(P2-P1)*((i-tBeg)/(tEnd-tBeg));
                gWallRim_helper(ca,cb,ta,i,h,Z_SCALE,sw);
                ca=cb;
                ta=i;
            }
            gWallRim_helper(ca,P2,ta,tEnd,h,Z_SCALE,sw);
        }
        else{
            // wrap manually in y-direction, some graphics card are bad at it
            REAL offset = 0;
            if (tBeg>tEnd)
                offset = -floor(tEnd);
            else
                offset = -floor(tBeg);

            tBeg += offset;
            tEnd += offset;

            gWallRim_helper(*p1,*p2,tBeg,tEnd,h,Z_SCALE,false);
        }

        //eWall::Render_helper(edge,(p1->x+p1->y)/SCALE,(p2->x+p2->y)/SCALE,40,height);
            
        if ( transparency )
            glEnable( GL_DEPTH_TEST );
    }

    // grow the wall again
    if ( se_mainGameTimer )
    {
        REAL time = se_mainGameTimer->Time();
        REAL ts = time - lastUpdate_;
        if ( ts > 0 )
        {
            lastUpdate_ = time;

            if ( renderHeight_ < .25 )
            {
                renderHeight_ = .25;
            }
            renderHeight_ *= 1 + 10 * ts;
            renderHeight_ += 5 * ts;
            if ( renderHeight_ > height )
            {
                renderHeight_ = height;
            }
        }

        if ( renderHeight_ < height )
        {
            DestroyDisplayList();
        }
    }

Here is the call graph for this function:

void gWallRim::OnBlocksCamera	(	eCamera *	camera,
		REAL	height
	)			const [protected, virtual]

called by the camera code when this wall is between the cycle and the camera

Parameters:

	cam	the camera that is blocked
	height	the maximal height the wall would be allowed to have without blocking the view

Reimplemented from eWall.

Definition at line 500 of file gWall.cpp.

References eWallRim::DestroyDisplayList(), and renderHeight_.

{
    DestroyDisplayList();

    // lower the wall so it now longer blocks the view
    if ( height < renderHeight_ )
    {
        renderHeight_ = height;
   }
    if ( renderHeight_ < .25 )
        renderHeight_ = .25;

Here is the call graph for this function:

REAL gWallRim::Height

(

void

)

[protected, virtual]

Returns:

Reimplemented from eWallRim.

Definition at line 525 of file gWall.cpp.

References renderHeight_.

{
    return renderHeight_;

REAL gWallRim::SeeHeight

(

void

)

[protected, virtual]

Returns:

Reimplemented from eWallRim.

Definition at line 540 of file gWall.cpp.

References renderHeight_.

{
    return renderHeight_ * 2;

---

Member Data Documentation

REAL gWallRim::renderHeight_ [mutable, private]

the height with which this wall is really rendered

Definition at line 65 of file gWall.h.

Referenced by Height(), OnBlocksCamera(), RenderReal(), and SeeHeight().

REAL gWallRim::lastUpdate_ [mutable, private]

time of the last render height update

Definition at line 66 of file gWall.h.

Referenced by RenderReal().

REAL gWallRim::tBeg_ [private]

Definition at line 68 of file gWall.h.

Referenced by RenderReal(), and Split().

REAL gWallRim::tEnd_ [private]

begin and end texture coordinates

Definition at line 68 of file gWall.h.

Referenced by RenderReal(), and Split().

---

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

• src/tron/gWall.h
• src/tron/gWall.cpp

---