Method CalculateTransform

libs/drape_frontend/arrow3d.cpp:462–513

}

std::pair<glsl::mat4, glsl::mat4> Arrow3d::CalculateTransform(ScreenBase const & screen, float dz, float scaleFactor,
                                                              dp::ApiVersion apiVersion) const
{
  double arrowScale = VisualParams::Instance().GetVisualScale() * arrow3d::kArrowSize * scaleFactor;
  if (screen.isPerspective())
  {
    double const t = GetNormalizedZoomLevel(screen.GetScale(), arrow3d::kArrow3dMinZoom);
    arrowScale *= (arrow3d::kArrow3dScaleMin * (1.0 - t) + arrow3d::kArrow3dScaleMax * t);
  }

  glm::quat const qx = glm::angleAxis(m_meshEulerAngles.x, glm::vec3{1.0f, 0.0f, 0.0f});
  glm::quat const qy = glm::angleAxis(m_meshEulerAngles.y, glm::vec3{0.0f, 1.0f, 0.0f});
  glm::quat qz = glm::angleAxis(static_cast<float>(m_azimuth + screen.GetAngle() + m_meshEulerAngles.z),
                                glm::vec3{0.0f, 0.0f, -1.0f});
  auto const rotationMatrix = glm::mat4_cast(qz * qy * qx);

  qz = glm::angleAxis(static_cast<float>(m_meshEulerAngles.z), glm::vec3{0.0f, 0.0f, -1.0f});
  auto const normalMatrix = glm::mat4_cast(qz * qy * qx);

  auto const scaleMatrix = glm::scale(
      glm::mat4(1.0f), glm::vec3{arrowScale, arrowScale, screen.isPerspective() ? arrowScale : 1.0} * m_meshScale);

  auto const translationMatrix = glm::translate(glm::mat4(1.0f), m_meshOffset);

  auto postProjectionScale = glm::vec3{2.0f / screen.PixelRect().SizeX(), 2.0f / screen.PixelRect().SizeY(), 1.0f};
  postProjectionScale.z =
      screen.isPerspective() ? std::min(postProjectionScale.x, postProjectionScale.y) * screen.GetScale3d() : 0.1f;
  auto const postProjectionScaleMatrix = glm::scale(glm::mat4(1.0f), postProjectionScale);

  m2::PointD const pos = screen.GtoP(m_position);
  auto const dX = static_cast<float>(2.0 * pos.x / screen.PixelRect().SizeX() - 1.0);
  auto const dY = static_cast<float>(2.0 * pos.y / screen.PixelRect().SizeY() - 1.0);
  auto const postProjectionTranslationMatrix = glm::translate(glm::mat4(1.0f), glm::vec3{dX, -dY, dz});

  auto modelTransform =
      postProjectionTranslationMatrix * postProjectionScaleMatrix * scaleMatrix * translationMatrix * rotationMatrix;

  if (screen.isPerspective())
  {
    glm::mat4 pTo3dView = glm::make_mat4x4(screen.Pto3dMatrix().m_data);
    auto postProjectionPerspective = pTo3dView * modelTransform;
    return std::make_pair(postProjectionPerspective, normalMatrix);
  }

  if (apiVersion == dp::ApiVersion::Metal)
  {
    modelTransform[3][2] = modelTransform[3][2] + 0.5f;
    modelTransform[2][2] = modelTransform[2][2] * 0.5f;
  }

  return std::make_pair(modelTransform, normalMatrix);
}
}  // namespace df