void FrontendRenderer::OnResize(ScreenBase const & screen)
{
m2::RectD const viewportRect = screen.isPerspective() ? screen.PixelRectIn3d() : screen.PixelRect();
m_myPositionController->UpdatePixelPosition(screen);
m_myPositionController->OnNewPixelRect();
m_viewport.SetViewport(0, 0, viewportRect.SizeX(), viewportRect.SizeY());
m_contextFactory->getDrawContext()->resize(viewportRect.SizeX(), viewportRect.SizeY());
RefreshProjection(screen);
RefreshPivotTransform(screen);
m_framebuffer->SetSize(viewportRect.SizeX(), viewportRect.SizeY());
}
m2::AnyRectD ToRotated(m2::RectD const & rect, Navigator const & navigator)
{
double const dx = rect.SizeX();
double const dy = rect.SizeY();
return m2::AnyRectD(rect.Center(),
navigator.Screen().GetAngle(),
m2::RectD(-dx/2, -dy/2, dx/2, dy/2));
}
void ScreenBase::SetFromRects(m2::AnyRectD const & glbRect, m2::RectD const & pxRect)
{
double hScale = glbRect.GetLocalRect().SizeX() / pxRect.SizeX();
double vScale = glbRect.GetLocalRect().SizeY() / pxRect.SizeY();
m_Scale = max(hScale, vScale);
m_Angle = glbRect.Angle();
m_Org = glbRect.GlobalCenter();
UpdateDependentParameters();
}
void Init()
{
m_depthLayer = m_f.GetLayer();
if (m_depthLayer == feature::LAYER_TRANSPARENT_TUNNEL)
m_depthLayer = feature::LAYER_EMPTY;
if (m_geomType == feature::GEOM_POINT)
m_priorityModifier = (double)m_f.GetPopulation() / 7E9;
else
{
m2::RectD const r = m_f.GetLimitRect(m_zoomLevel);
m_priorityModifier = min(1.0, r.SizeX() * r.SizeY() * 10000.0);
}
}
void Engine::SetRankPivot(SearchParams const & params, m2::RectD const & viewport,
bool viewportSearch, Query & processor)
{
if (!viewportSearch && params.IsValidPosition())
{
m2::PointD const pos = MercatorBounds::FromLatLon(params.m_lat, params.m_lon);
if (m2::Inflate(viewport, viewport.SizeX() / 4.0, viewport.SizeY() / 4.0).IsPointInside(pos))
{
processor.SetRankPivot(pos);
return;
}
}
processor.SetRankPivot(viewport.Center());
}
double CalculateScale(ScreenBase const & screen, m2::RectD const & localRect)
{
m2::RectD const pixelRect = screen.PixelRect();
return max(localRect.SizeX() / pixelRect.SizeX(), localRect.SizeY() / pixelRect.SizeY());
}
int GetTileScaleBase(m2::RectD const & r)
{
double const sz = max(r.SizeX(), r.SizeY());
return max(1, my::rounds(log((MercatorBounds::maxX - MercatorBounds::minX) / sz) / log(2.0)));
}
static bool empty_scr_rect(m2::RectD const & r)
{
double const eps = 1.0;
return (r.SizeX() < eps && r.SizeY() < eps);
}
bool CanShrinkInto(ScreenBase const & screen, m2::RectD const & boundRect)
{
m2::RectD clipRect = screen.ClipRect();
return (boundRect.SizeX() >= clipRect.SizeX())
&& (boundRect.SizeY() >= clipRect.SizeY());
}
double CalculateScale(m2::RectD const & pixelRect, m2::RectD const & localRect)
{
return max(localRect.SizeX() / pixelRect.SizeX(), localRect.SizeY() / pixelRect.SizeY());
}
ScreenBase const ShrinkAndScaleInto(ScreenBase const & screen, m2::RectD boundRect)
{
ReduceRectHack(boundRect);
ScreenBase res = screen;
m2::RectD globalRect = res.ClipRect();
m2::PointD newOrg = res.GetOrg();
double scale = 1;
double offs = 0;
if (globalRect.minX() < boundRect.minX())
{
offs = boundRect.minX() - globalRect.minX();
globalRect.Offset(offs, 0);
newOrg.x += offs;
if (globalRect.maxX() > boundRect.maxX())
{
double k = boundRect.SizeX() / globalRect.SizeX();
scale /= k;
/// scaling always occur pinpointed to the rect center...
globalRect.Scale(k);
/// ...so we should shift a rect after scale
globalRect.Offset(boundRect.minX() - globalRect.minX(), 0);
}
}
if (globalRect.maxX() > boundRect.maxX())
{
offs = boundRect.maxX() - globalRect.maxX();
globalRect.Offset(offs, 0);
newOrg.x += offs;
if (globalRect.minX() < boundRect.minX())
{
double k = boundRect.SizeX() / globalRect.SizeX();
scale /= k;
globalRect.Scale(k);
globalRect.Offset(boundRect.maxX() - globalRect.maxX(), 0);
}
}
if (globalRect.minY() < boundRect.minY())
{
offs = boundRect.minY() - globalRect.minY();
globalRect.Offset(0, offs);
newOrg.y += offs;
if (globalRect.maxY() > boundRect.maxY())
{
double k = boundRect.SizeY() / globalRect.SizeY();
scale /= k;
globalRect.Scale(k);
globalRect.Offset(0, boundRect.minY() - globalRect.minY());
}
}
if (globalRect.maxY() > boundRect.maxY())
{
offs = boundRect.maxY() - globalRect.maxY();
globalRect.Offset(0, offs);
newOrg.y += offs;
if (globalRect.minY() < boundRect.minY())
{
double k = boundRect.SizeY() / globalRect.SizeY();
scale /= k;
globalRect.Scale(k);
globalRect.Offset(0, boundRect.maxY() - globalRect.maxY());
}
}
res.SetOrg(globalRect.Center());
res.Scale(scale);
return res;
}
void Navigator::Move(double azDir, double factor)
{
m2::RectD const r = m_Screen.ClipRect();
m_Screen.MoveG(m2::PointD(r.SizeX() * factor * cos(azDir), r.SizeY() * factor * sin(azDir)));
}