/**
* Renders the AbstractAirspace on the canvas
* @param as AbstractAirspace to render
*/
void
Render(const AbstractAirspace& as)
{
int type = as.get_type();
if (type <= 0)
return;
// No intersections for this airspace
if (m_intersections.empty())
return;
// Select pens and brushes
#ifdef ENABLE_SDL
Color color =
Graphics::GetAirspaceColour(settings.colours[type]);
#ifdef ENABLE_OPENGL
color = color.with_alpha(48);
#endif
Brush brush(color);
#else
const Brush &brush = Graphics::GetAirspaceBrushByClass(type, settings);
canvas.set_text_color(light_color(Graphics::GetAirspaceColourByClass(type, settings)));
#endif
PixelRect rcd;
// Calculate top and bottom coordinate
rcd.top = chart.screenY(as.get_top_altitude(state));
if (as.is_base_terrain())
rcd.bottom = chart.screenY(fixed_zero);
else
rcd.bottom = chart.screenY(as.get_base_altitude(state));
// Iterate through the intersections
for (AirspaceIntersectionVector::const_iterator it = m_intersections.begin();
it != m_intersections.end(); ++it) {
const GeoPoint p_start = it->first;
const GeoPoint p_end = it->second;
const fixed distance_start = start.distance(p_start);
const fixed distance_end = start.distance(p_end);
// Determine left and right coordinate
rcd.left = chart.screenX(distance_start);
rcd.right = chart.screenX(distance_end);
// only one edge found, next edge must be beyond screen
if ((rcd.left == rcd.right) && (p_start == p_end)) {
rcd.right = chart.screenX(chart.getXmax());
}
// Draw the airspace
RenderBox(rcd, brush, settings.black_outline, type);
}
}
bool
GlueMapWindow::isClickOnTarget(const RasterPoint pc)
{
if (task == NULL)
return false;
if (XCSoarInterface::SettingsMap().TargetPan) {
ProtectedTaskManager::Lease task_manager(*task);
if (!task_manager->target_is_locked(XCSoarInterface::SettingsMap().TargetPanIndex))
return false;
const GeoPoint gnull(Angle::native(fixed_zero), Angle::native(fixed_zero));
const GeoPoint& t = task_manager->get_location_target(
XCSoarInterface::SettingsMap().TargetPanIndex, gnull);
if (t == gnull)
return false;
const GeoPoint gp = visible_projection.ScreenToGeo(pc.x, pc.y);
if (visible_projection.GeoToScreenDistance(gp.distance(t)) <
unsigned(Layout::Scale(10)))
return true;
}
return false;
}
GeoPoint
AirspaceCircle::closest_point(const GeoPoint& loc) const
{
const fixed d = loc.distance(m_center);
if (d <= m_radius)
return loc;
else
return m_center.intermediate_point(loc, m_radius);
}
void
AircraftSim::integrate(const Angle& heading, const fixed timestep)
{
GeoPoint v = endpoint(heading, timestep);
state.track = state.location.bearing(v);
state.ground_speed = v.distance(state.location)/timestep;
state.location = v;
state.altitude += state.vario*timestep;
state.time += timestep;
}
void
AATPoint::get_target_range_radial(fixed &range, fixed &radial) const
{
const fixed oldrange = range;
const GeoPoint fprev = get_previous()->get_location_remaining();
const GeoPoint floc = get_location();
const Angle radialraw = (floc.bearing(get_location_target()) -
fprev.bearing(floc)).as_bearing();
const fixed d = floc.distance(get_location_target());
const fixed radius = floc.distance(get_location_min());
const fixed rangeraw = min(fixed_one, d / radius);
radial = radialraw.as_delta().value_degrees();
const fixed rangesign = (fabs(radial) > fixed(90)) ?
fixed_minus_one : fixed_one;
range = rangeraw * rangesign;
if ((oldrange == fixed_zero) && (range == fixed_zero))
radial = fixed_zero;
}
bool
TargetMapWindow::isClickOnTarget(const RasterPoint pc)
{
if (task == NULL)
return false;
ProtectedTaskManager::Lease task_manager(*task);
if (!task_manager->has_target(target_index))
return false;
const GeoPoint gnull(Angle::zero(), Angle::zero());
const GeoPoint& t = task_manager->get_location_target(target_index, gnull);
if (t == gnull)
return false;
const GeoPoint gp = projection.ScreenToGeo(pc.x, pc.y);
if (projection.GeoToScreenDistance(gp.distance(t)) <
unsigned(Layout::Scale(10)))
return true;
return false;
}
bool
AirspaceCircle::inside(const GeoPoint &loc) const
{
return (loc.distance(m_center) <= m_radius);
}
