drape_ptr<MapLinearAnimation> GetSetRectAnimation(ScreenBase const & screen,
m2::AnyRectD const & startRect, m2::AnyRectD const & endRect)
{
auto anim = make_unique_dp<MapLinearAnimation>();
double const startScale = CalculateScale(screen.PixelRect(), startRect.GetLocalRect());
double const endScale = CalculateScale(screen.PixelRect(), endRect.GetLocalRect());
anim->SetRotate(startRect.Angle().val(), endRect.Angle().val());
anim->SetMove(startRect.GlobalCenter(), endRect.GlobalCenter(), screen);
anim->SetScale(startScale, endScale);
anim->SetMaxScaleDuration(kMaxAnimationTimeSec);
return anim;
}
void RulerHelper::Update(ScreenBase const & screen)
{
m2::PointD pivot = screen.PixelRect().Center();
int const minPxWidth = my::rounds(MinPixelWidth * df::VisualParams::Instance().GetVisualScale());
m2::PointD pt1 = screen.PtoG(pivot);
m2::PointD pt0 = screen.PtoG(pivot - m2::PointD(minPxWidth, 0));
double const distanceInMetres = MercatorBounds::DistanceOnEarth(pt0, pt1);
// convert metres to units for calculating m_metresDiff
double metersDiff = CalcMetresDiff(distanceInMetres);
bool const higherThanMax = metersDiff > MaxMetersWidth;
bool const lessThanMin = metersDiff < MinMetersWidth;
m_pixelLength = minPxWidth;
if (higherThanMax)
m_pixelLength = minPxWidth * 3 / 2;
else if (!lessThanMin)
{
double const a = ang::AngleTo(pt1, pt0);
pt0 = MercatorBounds::GetSmPoint(pt1, cos(a) * metersDiff, sin(a) * metersDiff);
m_pixelLength = my::rounds(pivot.Length(screen.GtoP(pt0)));
}
int drawScale = df::GetDrawTileScale(screen);
if (m_currentDrawScale < VISIBLE_RULER_BOTTOM_SCALE &&
drawScale >= VISIBLE_RULER_BOTTOM_SCALE)
{
SetTextDirty();
}
m_currentDrawScale = drawScale;
}
math::Matrix<float, 4, 4> Arrow3d::CalculateTransform(ScreenBase const & screen, float dz) const
{
double arrowScale = VisualParams::Instance().GetVisualScale() * kArrowSize;
if (screen.isPerspective())
{
static double const kLog2 = log(2.0);
double const kMaxZoom = scales::UPPER_STYLE_SCALE + 1.0;
double const zoomLevel = my::clamp(fabs(log(screen.GetScale()) / kLog2), kArrow3dMinZoom, kMaxZoom);
double const t = (zoomLevel - kArrow3dMinZoom) / (kMaxZoom - kArrow3dMinZoom);
arrowScale *= (kArrow3dScaleMin * (1.0 - t) + kArrow3dScaleMax * t);
}
double const scaleX = arrowScale * 2.0 / screen.PixelRect().SizeX();
double const scaleY = arrowScale * 2.0 / screen.PixelRect().SizeY();
double const scaleZ = screen.isPerspective() ? (0.002 * screen.GetDepth3d()) : 1.0;
m2::PointD const pos = screen.GtoP(m_position);
double const dX = 2.0 * pos.x / screen.PixelRect().SizeX() - 1.0;
double const dY = 2.0 * pos.y / screen.PixelRect().SizeY() - 1.0;
math::Matrix<float, 4, 4> scaleM = math::Identity<float, 4>();
scaleM(0, 0) = scaleX;
scaleM(1, 1) = scaleY;
scaleM(2, 2) = scaleZ;
math::Matrix<float, 4, 4> rotateM = math::Identity<float, 4>();
rotateM(0, 0) = cos(m_azimuth + screen.GetAngle());
rotateM(0, 1) = -sin(m_azimuth + screen.GetAngle());
rotateM(1, 0) = -rotateM(0, 1);
rotateM(1, 1) = rotateM(0, 0);
math::Matrix<float, 4, 4> translateM = math::Identity<float, 4>();
translateM(3, 0) = dX;
translateM(3, 1) = -dY;
translateM(3, 2) = dz;
math::Matrix<float, 4, 4> modelTransform = rotateM * scaleM * translateM;
if (screen.isPerspective())
return modelTransform * math::Matrix<float, 4, 4>(screen.Pto3dMatrix());
return modelTransform;
}
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());
}
int GetTileScaleBase(ScreenBase const & s, uint32_t tileSize)
{
ScreenBase tmpS = s;
tmpS.Rotate(-tmpS.GetAngle());
// slightly smaller than original to produce "antialiasing" effect using bilinear filtration.
int const halfSize = static_cast<int>(tileSize / 1.05 / 2.0);
m2::RectD glbRect;
m2::PointD const pxCenter = tmpS.PixelRect().Center();
tmpS.PtoG(m2::RectD(pxCenter - m2::PointD(halfSize, halfSize),
pxCenter + m2::PointD(halfSize, halfSize)),
glbRect);
return GetTileScaleBase(glbRect);
}
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());
}
void MyPositionController::UpdatePixelPosition(ScreenBase const & screen)
{
m_pixelRect = screen.isPerspective() ? screen.PixelRectIn3d() : screen.PixelRect();
m_positionYOffset = screen.isPerspective() ? kPositionOffsetYIn3D : kPositionOffsetY;
}
m2::PointD CalculateCenter(ScreenBase const & screen, m2::PointD const & userPos,
m2::PointD const & pixelPos, double azimuth)
{
double const scale = screen.GlobalRect().GetLocalRect().SizeX() / screen.PixelRect().SizeX();
return CalculateCenter(scale, screen.PixelRect(), userPos, pixelPos, azimuth);
}
void Arrow3d::Render(ScreenBase const & screen, ref_ptr<dp::GpuProgramManager> mng)
{
// Unbind current VAO, because glVertexAttributePointer and glEnableVertexAttribute can affect it.
GLFunctions::glBindVertexArray(0);
ref_ptr<dp::GpuProgram> prg = mng->GetProgram(gpu::ARROW_3D_PROGRAM);
prg->Bind();
if (!m_isInitialized)
{
Build(prg);
m_isInitialized = true;
}
dp::ApplyState(m_state, prg);
static double const kLog2 = log(2.0);
double const kMaxZoom = scales::UPPER_STYLE_SCALE + 1.0;
double const zoomLevel = my::clamp(fabs(log(screen.GetScale()) / kLog2), kArrow3dMinZoom, kMaxZoom);
double const t = (zoomLevel - kArrow3dMinZoom) / (kMaxZoom - kArrow3dMinZoom);
double const arrowScale = kArrow3dScaleMin * (1.0 - t) + kArrow3dScaleMax * t;
double const scaleX = m_pixelWidth * arrowScale * 2.0 / screen.PixelRect().SizeX() / kArrowSizeX;
double const scaleY = m_pixelHeight * arrowScale * 2.0 / screen.PixelRect().SizeY() / kArrowSizeY;
double const scaleZ = scaleX;
m2::PointD const pos = screen.GtoP(m_position);
double const dX = 2.0 * pos.x / screen.PixelRect().SizeX() - 1.0;
double const dY = 2.0 * pos.y / screen.PixelRect().SizeY() - 1.0;
math::Matrix<float, 4, 4> scaleM = math::Identity<float, 4>();
scaleM(0, 0) = scaleX;
scaleM(1, 1) = scaleY;
scaleM(2, 2) = scaleZ;
math::Matrix<float, 4, 4> rotateM = math::Identity<float, 4>();
rotateM(0, 0) = cos(m_azimuth + screen.GetAngle());
rotateM(0, 1) = -sin(m_azimuth + screen.GetAngle());
rotateM(1, 0) = -rotateM(0, 1);
rotateM(1, 1) = rotateM(0, 0);
math::Matrix<float, 4, 4> translateM = math::Identity<float, 4>();
translateM(3, 0) = dX;
translateM(3, 1) = -dY;
math::Matrix<float, 4, 4> modelTransform = rotateM * scaleM * translateM;
modelTransform = modelTransform * math::Matrix<float, 4, 4>(screen.Pto3dMatrix());
dp::UniformValuesStorage uniforms;
uniforms.SetMatrix4x4Value("m_transform", modelTransform.m_data);
dp::ApplyUniforms(uniforms, prg);
GLFunctions::glBindBuffer(m_bufferId, gl_const::GLArrayBuffer);
GLFunctions::glEnableVertexAttribute(m_attributePosition);
GLFunctions::glVertexAttributePointer(m_attributePosition, 3, gl_const::GLFloatType, false, 0, 0);
GLFunctions::glBindBuffer(m_bufferNormalsId, gl_const::GLArrayBuffer);
GLFunctions::glEnableVertexAttribute(m_attributeNormal);
GLFunctions::glVertexAttributePointer(m_attributeNormal, 3, gl_const::GLFloatType, false, 0, 0);
GLFunctions::glDrawArrays(gl_const::GLTriangles, 0, m_vertices.size() / 3);
prg->Unbind();
GLFunctions::glBindBuffer(0, gl_const::GLArrayBuffer);
}
