#include <plane_display.h>

Inheritance diagram for Radar::PlaneDisplay:

Classes
struct	AnimationItem

Public Member Functions
	PlaneDisplay ()

void	Draw (const Sensor &sensor, VSSprite , VSSprite )

void	OnDockEnd ()

void	OnJumpEnd ()

Public Member Functions inherited from Radar::DualDisplayBase
	DualDisplayBase ()

void	OnPauseBegin ()

void	OnPauseEnd ()

Public Member Functions inherited from Radar::Display
virtual	~Display ()

virtual void	OnJumpBegin ()

Protected Types
typedef std::vector< float >	AngleSequence

typedef std::queue< AnimationItem >	AnimationCollection

Protected Member Functions
void	DrawGround (const Sensor &, const ViewArea &)

void	DrawNear (const Sensor &, const Sensor::TrackCollection &)

void	DrawDistant (const Sensor &, const Sensor::TrackCollection &)

void	DrawTrack (const Sensor &, const ViewArea &, const Track &, float)

void	DrawTarget (Track::Type::Value, const Vector &, const Vector &, float, const GFXColor &)

void	DrawTargetMarker (const Vector &, const Vector &, const Vector &, float, const GFXColor &, bool)

void	Animate ()

void	PrepareAnimation (const Vector &, const Vector &, const AngleSequence &, const AngleSequence &, const AngleSequence &)

void	CalculateRotation ()

Vector	Projection (const ViewArea &, const Vector &)

Protected Member Functions inherited from Radar::DualDisplayBase
float	Jitter (float errorOffset, float errorRange)

void	Jitter (float errorOffset, float errorRange, Vector &position)

Protected Attributes
Vector	finalCameraAngle

Vector	currentCameraAngle

Vector	xrotation

Vector	yrotation

Vector	zrotation

std::vector< Vector >	groundPlane

float	radarTime

AnimationCollection	animation

float	lastAnimationTime

AngleSequence	nothingSequence

AngleSequence	bounceSequence

AngleSequence	cosineSequence

Protected Attributes inherited from Radar::DualDisplayBase
ViewArea	leftRadar

ViewArea	rightRadar

bool	isPaused

RandomEngine	randomEngine

RandomDistribution	randomDistribution

RandomGenerator	randomGenerator

Detailed Description

Definition at line 21 of file plane_display.h.

Member Typedef Documentation

typedef std::vector<float> Radar::PlaneDisplay::AngleSequence

protected

Definition at line 32 of file plane_display.h.

typedef std::queue<AnimationItem> Radar::PlaneDisplay::AnimationCollection

protected

Definition at line 62 of file plane_display.h.

Constructor & Destructor Documentation

Radar::PlaneDisplay::PlaneDisplay ( )

Definition at line 46 of file plane_display.cpp.

References bounceSequence, CalculateRotation(), cosineSequence, f, groundPlane, M_PI, nothingSequence, and Vector.

     : finalCameraAngle(Degree2Radian(30), Degree2Radian(0), Degree2Radian(0)),
       currentCameraAngle(finalCameraAngle),
       radarTime(0.0),
       lastAnimationTime(0.0)
 {
     using namespace boost::assign; // vector::operator+=
 
     CalculateRotation();
 
     // Calculate ground plane
     const float edges = 32;
     const float full = 2 * M_PI;
     const float step = full / edges;
     for (float angle = 0.0; angle < full; angle += step)
     {
         groundPlane.push_back(Vector(cosf(angle), 0.0f, sinf(angle)));
     }
 
     // Sequences start in 1 and ends in 0
     nothingSequence += 0.0;
     bounceSequence += 1.0, 0.9999, 0.9991, 0.9964, 0.9900, 0.9775, 0.9559, 0.9216, 0.8704, 0.7975, 0.6975, 0.5644, 0.3916, 0.1719, 0.0, 0.1287, 0.2164, 0.2535, 0.2297, 0.1343, 0.0, 0.0660, 0.0405, 0.0, 0.0341, 0.0;
     cosineSequence += 1.0, 0.999391, 0.997564, 0.994522, 0.990268, 0.984808, 0.978148, 0.970296, 0.961262, 0.951057, 0.939693, 0.927184, 0.913545, 0.898794, 0.882948, 0.866025, 0.848048, 0.829038, 0.809017, 0.788011, 0.766044, 0.743145, 0.71934, 0.694658, 0.669131, 0.642788, 0.615662, 0.587785, 0.559193, 0.529919, 0.5, 0.469472, 0.438371, 0.406737, 0.374607, 0.34202, 0.309017, 0.275637, 0.241922, 0.207911, 0.173648, 0.139173, 0.104528, 0.069756, 0.034899, 0.0;
 }

Member Function Documentation

void Radar::PlaneDisplay::Animate ( )

protected

Definition at line 176 of file plane_display.cpp.

References animation, CalculateRotation(), currentCameraAngle, lastAnimationTime, and radarTime.

Referenced by Draw().

 {
     if (!animation.empty())
     {
         if (radarTime > lastAnimationTime + animation.front().duration)
         {
             currentCameraAngle = animation.front().position;
             CalculateRotation();
             animation.pop();
             lastAnimationTime = radarTime;
         }
     }
 }

void Radar::PlaneDisplay::CalculateRotation ( )

protected

Definition at line 71 of file plane_display.cpp.

References currentCameraAngle, Vector, xrotation, yrotation, and zrotation.

Referenced by Animate(), and PlaneDisplay().

 {
     const float cosx = cosf(currentCameraAngle.x);
     const float cosy = cosf(currentCameraAngle.y);
     const float cosz = cosf(currentCameraAngle.z);
     const float sinx = sinf(currentCameraAngle.x);
     const float siny = sinf(currentCameraAngle.y);
     const float sinz = sinf(currentCameraAngle.z);
 
     xrotation = Vector(cosy * cosz,
                        sinx * siny * cosz - cosx * sinz,
                        cosx * siny * cosz + sinx * sinz);
     yrotation = Vector(cosy * sinz,
                        cosx * cosz + sinx * siny * sinz,
                        cosx * siny * sinz - sinx * cosz);
     zrotation = Vector(-siny,
                        sinx * cosy,
                        cosx * cosy);
 }

void Radar::PlaneDisplay::Draw	(	const Sensor &	sensor,
		VSSprite *	nearSprite,
		VSSprite *	distantSprite
	)

virtual

Implements Radar::Display.

Definition at line 143 of file plane_display.cpp.

References Animate(), DEPTHTEST, DEPTHWRITE, VSSprite::Draw(), DrawDistant(), DrawNear(), Radar::Sensor::FindTracksInRange(), GetElapsedTime(), GFXDisable(), GFXEnable(), GFXPointSize(), Radar::DualDisplayBase::leftRadar, radarTime, Radar::DualDisplayBase::rightRadar, Radar::ViewArea::SetSprite(), and SMOOTH.

 {
     assert(nearSprite || distantSprite); // There should be at least one radar display
 
     radarTime += GetElapsedTime();
 
     leftRadar.SetSprite(nearSprite);
     rightRadar.SetSprite(distantSprite);
 
     if (nearSprite)
         nearSprite->Draw();
     if (distantSprite)
         distantSprite->Draw();
 
     Sensor::TrackCollection tracks = sensor.FindTracksInRange();
 
     Animate();
 
     GFXEnable(DEPTHTEST);
     GFXEnable(DEPTHWRITE);
     GFXEnable(SMOOTH);
 
     DrawNear(sensor, tracks);
     DrawDistant(sensor, tracks);
 
     GFXPointSize(1);
     GFXDisable(DEPTHTEST);
     GFXDisable(DEPTHWRITE);
     GFXDisable(SMOOTH);
 }

void Radar::PlaneDisplay::DrawDistant	(	const Sensor &	sensor,
		const Sensor::TrackCollection &	tracks
	)

protected

Definition at line 290 of file plane_display.cpp.

References DrawGround(), DrawTrack(), Radar::Sensor::GetCloseRange(), Radar::Sensor::GetMaxRange(), Radar::ViewArea::IsActive(), and Radar::DualDisplayBase::rightRadar.

Referenced by Draw().

 {
     // Draw all near tracks (distance scaled)
 
     if (!rightRadar.IsActive())
         return;
 
     float minRange = sensor.GetCloseRange();
     float maxRange = sensor.GetMaxRange();
 
     DrawGround(sensor, rightRadar);
 
     for (Sensor::TrackCollection::const_iterator it = tracks.begin(); it != tracks.end(); ++it)
     {
         if ((it->GetDistance() < minRange) || (it->GetDistance() > maxRange))
             continue;
 
         DrawTrack(sensor, rightRadar, *it, maxRange);
     }
 }

void Radar::PlaneDisplay::DrawGround	(	const Sensor &	sensor,
		const ViewArea &	radarView
	)

protected

Definition at line 217 of file plane_display.cpp.

References GFXColor::a, f, Radar::ViewArea::GetColor(), Radar::Sensor::GetLockCone(), GFXBegin(), GFXColorf(), GFXEnd(), GFXLINE, GFXLINESTRIP, GFXLineWidth(), GFXPOLY, GFXVertexf(), groundPlane, Projection(), and Vector.

Referenced by DrawDistant(), and DrawNear().

 {
     GFXColor groundColor = radarView.GetColor();
     const float outer = 3.0 / 3.0;
     const float middle = 2.0 / 3.0;
     const float inner = 1.0 / 3.0;
 
     groundColor.a = 0.1;
     GFXColorf(groundColor);
     GFXLineWidth(0.5);
     GFXBegin(GFXPOLY);
     for (std::vector<Vector>::const_iterator it = groundPlane.begin(); it != groundPlane.end(); ++it)
     {
         GFXVertexf(Projection(radarView, outer * (*it)));
     }
     GFXEnd();
 
     groundColor.a = 0.4;
     GFXColorf(groundColor);
     GFXBegin(GFXLINESTRIP);
     for (std::vector<Vector>::const_iterator it = groundPlane.begin(); it != groundPlane.end(); ++it)
     {
         GFXVertexf(Projection(radarView, middle * (*it)));
     }
     GFXVertexf(Projection(radarView, middle * groundPlane.front()));
     GFXEnd();
 
     GFXBegin(GFXLINESTRIP);
     for (std::vector<Vector>::const_iterator it = groundPlane.begin(); it != groundPlane.end(); ++it)
     {
         GFXVertexf(Projection(radarView, inner * (*it)));
     }
     GFXVertexf(Projection(radarView, inner * groundPlane.front()));
     GFXEnd();
 
     groundColor.a = 0.4;
     const float xcone = cosf(sensor.GetLockCone());
     const float zcone = sinf(sensor.GetLockCone());
     const float innerCone = inner;
     const float outerCone = outer;
     Vector leftCone(xcone, 0.0f, zcone);
     Vector rightCone(-xcone, 0.0f, zcone);
     GFXColorf(groundColor);
     GFXBegin(GFXLINE);
     GFXVertexf(Projection(radarView, outerCone * leftCone));
     GFXVertexf(Projection(radarView, innerCone * leftCone));
     GFXVertexf(Projection(radarView, outerCone * rightCone));
     GFXVertexf(Projection(radarView, innerCone * rightCone));
     GFXEnd();
     GFXLineWidth(1);
 }

void Radar::PlaneDisplay::DrawNear	(	const Sensor &	sensor,
		const Sensor::TrackCollection &	tracks
	)

protected

Definition at line 269 of file plane_display.cpp.

References DrawGround(), DrawTrack(), Radar::Sensor::GetCloseRange(), Radar::ViewArea::IsActive(), and Radar::DualDisplayBase::leftRadar.

Referenced by Draw().

 {
     // Draw all near tracks (distance scaled)
 
     if (!leftRadar.IsActive())
         return;
 
     float maxRange = sensor.GetCloseRange();
 
     DrawGround(sensor, leftRadar);
 
     for (Sensor::TrackCollection::const_iterator it = tracks.begin(); it != tracks.end(); ++it)
     {
         if (it->GetDistance() > maxRange)
             continue;
 
         DrawTrack(sensor, leftRadar, *it, maxRange);
     }
 }

void Radar::PlaneDisplay::DrawTarget	(	Track::Type::Value	unitType,
		const Vector &	head,
		const Vector &	ground,
		float	trackSize,
		const GFXColor &	color
	)

protected

Definition at line 387 of file plane_display.cpp.

References GFXColor::a, GFXBegin(), GFXColorf(), GFXEnd(), GFXLINE, GFXLineWidth(), GFXPOINT, GFXPointSize(), and GFXVertexf().

Referenced by DrawTrack().

 {
     // Draw leg
     GFXColor legColor = color;
     legColor.a /= 2;
     GFXLineWidth(0.2);
     GFXColorf(legColor);
     GFXBegin(GFXLINE);
     GFXVertexf(head);
     GFXVertexf(ground);
     GFXEnd();
 
     // Draw head
     GFXColorf(color);
     GFXPointSize(trackSize);
     GFXBegin(GFXPOINT);
     GFXVertexf(head);
     GFXEnd();
 }

void Radar::PlaneDisplay::DrawTargetMarker	(	const Vector &	head,
		const Vector &	ground,
		const Vector &	center,
		float	trackSize,
		const GFXColor &	color,
		bool	drawArea
	)

protected

Definition at line 411 of file plane_display.cpp.

References GFXColor::a, f, g_game, GFXBegin(), GFXColorf(), GFXEnd(), GFXLINESTRIP, GFXLineWidth(), GFXPOLY, GFXVertex3f(), GFXVertexf(), max(), size, game_data_t::x_resolution, and game_data_t::y_resolution.

Referenced by DrawTrack().

 {
     if (drawArea)
     {
         GFXColor areaColor = color;
         areaColor.a /= 4;
         GFXColorf(areaColor);
         GFXBegin(GFXPOLY);
         GFXVertexf(head);
         GFXVertexf(ground);
         GFXVertexf(center);
         GFXEnd();
     }
 
     // Diamond
     float size = 6.0 * std::max(trackSize, 1.0f);
     float xsize = size / g_game.x_resolution;
     float ysize = size / g_game.y_resolution;
 
     GFXColorf(color);
     GFXLineWidth(1);
     GFXBegin(GFXLINESTRIP);
     GFXVertex3f(head.x - xsize, head.y, 0.0f);
     GFXVertex3f(head.x, head.y - ysize, 0.0f);
     GFXVertex3f(head.x + xsize, head.y, 0.0f);
     GFXVertex3f(head.x, head.y + ysize, 0.0f);
     GFXVertex3f(head.x - xsize, head.y, 0.0f);
     GFXEnd();
 }

void Radar::PlaneDisplay::DrawTrack	(	const Sensor &	sensor,
		const ViewArea &	radarView,
		const Track &	track,
		float	maxRange
	)

protected

Definition at line 312 of file plane_display.cpp.

References GFXColor::a, Radar::Track::Type::Cargo, center, DrawTarget(), DrawTargetMarker(), Radar::Track::ExplodingProgress(), f, Radar::Sensor::GetColor(), anonymous_namespace{bubble_display.cpp}::GetDangerRate(), Radar::Track::GetPosition(), Radar::Track::GetSize(), Radar::Track::GetType(), Radar::Track::HasActiveECM(), Radar::Sensor::IdentifyThreat(), Radar::Sensor::InsideNebula(), Radar::Track::IsExploding(), Radar::Sensor::IsTracking(), Radar::DualDisplayBase::Jitter(), max(), Radar::Track::Type::Nebula, Projection(), radarTime, Radar::Sensor::UseObjectRecognition(), Radar::Sensor::UseThreatAssessment(), and Vector.

Referenced by DrawDistant(), and DrawNear().

 {
     const Track::Type::Value unitType = track.GetType();
     GFXColor color = sensor.GetColor(track);
 
     Vector position = track.GetPosition();
     Vector scaledPosition = Vector(position.x, -position.y, position.z) / maxRange;
     if (scaledPosition.Magnitude() > 1.0)
         return;
 
     // FIXME: Integrate radar into damage/repair system
     // FIXME: Jitter does not work when entering a nebula
     // FIXME: Jitter does not work close by
     if (sensor.InsideNebula())
     {
         Jitter(0.0, 0.01, scaledPosition);
     }
     else
     {
         const bool isNebula = (track.GetType() == Track::Type::Nebula);
         const bool isEcmActive = track.HasActiveECM();
         if (isNebula || isEcmActive)
         {
             const float errorOffset = (scaledPosition.x > 0.0 ? 0.01 : -0.01);
             const float errorRange = 0.03;
             Jitter(errorOffset, errorRange, scaledPosition);
         }
     }
 
     Vector head = Projection(radarView, scaledPosition);
 
     Vector scaledGround(scaledPosition.x, 0, scaledPosition.z);
     Vector ground = Projection(radarView, scaledGround);
 
     const bool isBelowGround = (scaledPosition.y > 0); // Y has been inverted
 
     // Tracks below ground are muted
     if (isBelowGround)
         color.a /= 3;
     // and so is cargo
     if (track.GetType() == Track::Type::Cargo)
         color.a /= 4;
 
     if (sensor.UseThreatAssessment())
     {
         float dangerRate = GetDangerRate(sensor.IdentifyThreat(track));
         if (dangerRate > 0.0)
         {
             // Blinking track
             color.a *= cosf(dangerRate * radarTime);
         }
     }
 
     // Fade out dying ships
     if (track.IsExploding())
     {
         color.a *= (1.0 - track.ExplodingProgress());
     }
 
     float trackSize = std::max(1.0f, std::log10(track.GetSize()));
     if (track.GetType() != Track::Type::Cargo)
         trackSize += 1.0;
 
     DrawTarget(unitType, head, ground, trackSize, color);
 
     if (sensor.IsTracking(track))
     {
         Vector center = Projection(radarView, Vector(0, 0, 0));
         DrawTargetMarker(head, ground, center, trackSize, color, sensor.UseObjectRecognition());
     }
 }

void Radar::PlaneDisplay::OnDockEnd ( )

virtual

Reimplemented from Radar::Display.

Definition at line 129 of file plane_display.cpp.

References bounceSequence, anonymous_namespace{plane_display.cpp}::Degree2Radian(), finalCameraAngle, nothingSequence, PrepareAnimation(), and Vector.

 {
     // Bounce from upright position
     Vector undockCameraAngle(Degree2Radian(90), finalCameraAngle.y, finalCameraAngle.z);
     PrepareAnimation(undockCameraAngle, finalCameraAngle, bounceSequence, nothingSequence, nothingSequence);
 }

void Radar::PlaneDisplay::OnJumpEnd ( )

virtual

Reimplemented from Radar::Display.

Definition at line 136 of file plane_display.cpp.

References cosineSequence, anonymous_namespace{plane_display.cpp}::Degree2Radian(), finalCameraAngle, nothingSequence, PrepareAnimation(), and Vector.

 {
     // Full rotation around y-axis
     Vector jumpCameraAngle(finalCameraAngle.x, Degree2Radian(360), finalCameraAngle.z);
     PrepareAnimation(jumpCameraAngle, finalCameraAngle, nothingSequence, cosineSequence, nothingSequence);
 }

void Radar::PlaneDisplay::PrepareAnimation	(	const Vector &	fromAngle,
		const Vector &	toAngle,
		const AngleSequence &	xsequence,
		const AngleSequence &	ysequence,
		const AngleSequence &	zsequence
	)

protected

Definition at line 91 of file plane_display.cpp.

References animation, Radar::PlaneDisplay::AnimationItem::duration, i, max(), Radar::PlaneDisplay::AnimationItem::position, and Vector.

Referenced by OnDockEnd(), and OnJumpEnd().

 {
     AnimationItem firstItem;
     firstItem.duration = 0.0;
     firstItem.position = fromAngle;
     animation.push(firstItem);
 
     float duration = 2.0;
 
     // Use the longest-running sequence and zero-pad shorter sequuences
     AngleSequence::size_type longestSequenceSize = xsequence.size();
     longestSequenceSize = std::max(longestSequenceSize, ysequence.size());
     longestSequenceSize = std::max(longestSequenceSize, zsequence.size());
     for (AngleSequence::size_type i = 0; i < longestSequenceSize; ++i)
     {
         float xentry = (i < xsequence.size()) ? xsequence[i] : 0.0;
         float yentry = (i < ysequence.size()) ? ysequence[i] : 0.0;
         float zentry = (i < zsequence.size()) ? zsequence[i] : 0.0;
         float xangle = toAngle.x + xentry * (fromAngle.x - toAngle.x);
         float yangle = toAngle.y + yentry * (fromAngle.y - toAngle.y);
         float zangle = toAngle.z + zentry * (fromAngle.z - toAngle.z);
         AnimationItem item;
         item.duration = duration;
         item.position = Vector(xangle, yangle, zangle);
         animation.push(item);
         duration = 0.05;
     }
 
     AnimationItem finalItem;
     finalItem.duration = duration;
     finalItem.position = toAngle;
     animation.push(finalItem);
 }

Vector Radar::PlaneDisplay::Projection	(	const ViewArea &	radarView,
		const Vector &	position
	)

protected

Definition at line 190 of file plane_display.cpp.

References Radar::ViewArea::Scale(), Vector, x, xrotation, y, yrotation, z, and zrotation.

Referenced by DrawGround(), and DrawTrack().

 {
     // 1. Rotate
     float rx = position.Dot(xrotation);
     float ry = position.Dot(yrotation);
     float rz = position.Dot(zrotation);
 
     // 2. Project perspective
     // Using the symmetric viewing volume where right = -left and top = -bottom
     // gives us this perspective projection matrix
     //   n/r           0             0             0
     //   0             n/t           0             0
     //   0             0             -(f+n)/(f-n)  -2fn/(f-n)
     //   0             0             -1            0
     // location = M_perspective * rotatedPosition
     const float nearDistance = -0.5; // -0.25 => zoom out, -0.75 => zoom in
     const float farDistance = 0.5;
     const float top = 0.5;
     const float right = 0.5;
     float x = rx * (nearDistance / right);
     float y = ry * (nearDistance / top);
     float z = (rz * (- (farDistance + nearDistance) / (farDistance - nearDistance)) - 2.0 * farDistance * nearDistance / (farDistance - nearDistance));
 
     // 3. Scale onto radarView
     return radarView.Scale(Vector(x, y, z));
 }