.github/workflows/linux-check.yaml

@@ -61,6 +61,10 @@ jobs:
               libgl1-mesa-dev \
               libglvnd-dev \
               libharfbuzz-dev \
+              libxrandr-dev \
+              libxinerama-dev \
+              libxcursor-dev \
+              libxi-dev \
               qt6-base-dev \
               libqt6svg6-dev \
               qt6-positioning-dev \
@@ -128,6 +132,10 @@ jobs:
               libgl1-mesa-dev \
               libglvnd-dev \
               libharfbuzz-dev \
+              libxrandr-dev \
+              libxinerama-dev \
+              libxcursor-dev \
+              libxi-dev \
               qt6-base-dev \
               libqt6svg6-dev \
               qt6-positioning-dev \

.gitmodules

@@ -59,3 +59,12 @@
 [submodule "3party/utfcpp"]
 	path = 3party/utfcpp
 	url = https://github.com/nemtrif/utfcpp.git
+[submodule "3party/glfw"]
+	path = 3party/glfw
+	url = https://github.com/glfw/glfw.git
+[submodule "3party/CMake-MetalShaderSupport"]
+	path = 3party/CMake-MetalShaderSupport
+	url = https://github.com/dpogue/CMake-MetalShaderSupport.git
+[submodule "3party/imgui/imgui"]
+	path = 3party/imgui/imgui
+	url = https://github.com/ocornut/imgui

3party/CMake-MetalShaderSupport

@@ -0,0 +1 @@
+Subproject commit 989857d2e5e54869c35ad06fb21a67d12a2dbc67

3party/CMakeLists.txt

@@ -66,4 +66,19 @@ add_subdirectory(vulkan_wrapper)
 
 if (PLATFORM_DESKTOP)
   add_subdirectory(libtess2)
+
+  set(GLFW_BUILD_DOCS OFF CACHE BOOL "")
+  set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "")
+  set(GLFW_BUILD_TESTS OFF CACHE BOOL "")
+  set(GLFW_INSTALL OFF CACHE BOOL "")
+  set(GLFW_VULKAN_STATIC OFF CACHE BOOL "")
+  set(GLFW_BUILD_WAYLAND OFF CACHE BOOL "")
+  # Disable ARC for glfw and re-enable after it because it's globally set in the root CMakeLists.txt
+  set(CMAKE_OBJC_FLAGS "")
+  add_subdirectory(glfw)
+  set_target_properties(glfw PROPERTIES UNITY_BUILD OFF)
+  set_target_properties(glfw PROPERTIES XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC NO)
+  set(CMAKE_OBJC_FLAGS -fobjc-arc)
+
+  add_subdirectory(imgui)
 endif()

3party/glfw

@@ -0,0 +1 @@
+Subproject commit 21fea01161e0d6b70c0c5c1f52dc8e7a7df14a50

3party/imgui/CMakeLists.txt

@@ -0,0 +1,16 @@
+project(imgui)
+
+set(SRC
+  imgui/imgui_draw.cpp
+  imgui/imgui_tables.cpp
+  imgui/imgui_widgets.cpp
+  imgui/imgui.cpp
+  imgui/backends/imgui_impl_glfw.cpp
+)
+
+add_library(${PROJECT_NAME} ${SRC})
+target_include_directories(${PROJECT_NAME} 
+  PRIVATE ${OMIM_ROOT}/3party/glfw/include
+  PUBLIC ${OMIM_ROOT}/3party/imgui/imgui
+  PUBLIC .
+)

3party/imgui/imgui

@@ -0,0 +1 @@
+Subproject commit 6982ce43f5b143c5dce5fab0ce07dd4867b705ae

CMakeLists.txt

@@ -90,6 +90,19 @@ else()
   message(FATAL_ERROR "Unsupported platform: ${CMAKE_SYSTEM_NAME}")
 endif()
 
+if(${PLATFORM_MAC})
+  set(XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC YES)
+
+  # Metal language support
+  list(APPEND CMAKE_MODULE_PATH ${OMIM_ROOT}/3party/CMake-MetalShaderSupport/cmake)
+  include(CheckLanguage)
+  include(MetalShaderSupport)
+  check_language(Metal)
+  if(CMAKE_Metal_COMPILER)
+    enable_language(Metal)
+  endif()
+endif()
+
 # Sanitizer
 if (PLATFORM_DESKTOP)
   # https://clang.llvm.org/docs/UsersManual.html#controlling-code-generation
@@ -384,6 +397,7 @@ if (PLATFORM_DESKTOP)
     add_subdirectory(qt)
     omim_add_tool_subdirectory(skin_generator)
   endif()
+  add_subdirectory(dev_sandbox)
 endif()
 
 omim_add_test_subdirectory(qt_tstfrm)

data/copyright.html

@@ -155,6 +155,12 @@
     <li><a href="https://chromium.googlesource.com/chromium/src/courgette/">Chromium's Courgette</a>;
       <a href="#bsd3-license" class="license">BSD License</a></li>
 
+    <li><a href="https://github.com/dpogue/CMake-MetalShaderSupport">CMake Metal support files</a><br>
+      &copy; 2024 Darryl Pogue and Contributors;<a href="#cmake-support-license" class="license">License</a></li>
+      
+    <li><a href="https://github.com/ocornut/imgui">Dear ImGui</a><br>
+      &copy; 2014-2025 Omar Cornut; <a href="#mit-license" class="license">MIT License</a></li>
+    
     <li><a href="https://libexpat.github.io">Expat</a><br>&copy; 1998&ndash;2000 Thai Open Source Software Center Ltd and Clark Cooper,
       &copy; 2001&ndash;2019 Expat maintainers; <a href="#mit-license" class="license">MIT License</a></li>
 
@@ -164,6 +170,9 @@
     <li><a href="http://www.freetype.org">FreeType</a><br>
       &copy; 2013 The FreeType Project; <a href="#freetype-license" class="license">FTL</a></li>
 
+    <li><a href="https://www.glfw.org/">GLFW</a><br>
+      &copy; 2002-2006 Marcus Geelnard;2006-2019 Camilla Löwy; <a href="#zlib-license" class="license">Zlib License</a></li>  
+
     <li><a href="http://www.g-truc.net/project-0016.html">GLM</a><br>
       &copy; 2005&ndash;2014 G-Truc Creation; <a href="#mit-license" class="license">MIT License</a></li>
 
@@ -1058,6 +1067,54 @@ of the copyright holder.</p>
 
 </div>
 
+<div class="section">
+
+  <h2 id="cmake-support-license">CMake Metal support files</h2>
+  <p>Copyright 2024 Darryl Pogue and Contributors</p>
+  <p>All rights reserved.</p>
+  
+  <p>Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:</p>
+  
+  <p>* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.</p>
+  
+  <p>* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.</p>
+  
+  <p>* Neither the name of Kitware, Inc. nor the names of Contributors may be used to endorse or promote products derived from this software without specific prior written permission.</p>
+  
+  <p>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.</p>
+  
+  <p>------------------------------------------------------------------------------</p>
+  
+  <p>See version control history for details of individual contributions.</p>
+  
+  <p>The above copyright and license notice applies to distributions of
+  CMake in source and binary form.  Third-party software packages supplied
+  with CMake under compatible licenses provide their own copyright notices
+  documented in corresponding subdirectories or source files.</p>
+  
+  <p>------------------------------------------------------------------------------</p>
+  
+  <p>CMake was initially developed by Kitware with the following sponsorship:</p>
+  
+  <p>* National Library of Medicine at the National Institutes of Health as part of the Insight Segmentation and Registration Toolkit (ITK).</p>
+  
+  <p>* US National Labs (Los Alamos, Livermore, Sandia) ASC Parallel Visualization Initiative.</p>
+  
+  <p>* National Alliance for Medical Image Computing (NAMIC) is funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.</p>
+  
+  <p>* Kitware, Inc.</p>
+</div>
+
 <div class="section">
 
   <h2 id="freetype-license">The FreeType Project License</h2>

dev_sandbox/CMakeLists.txt

@@ -0,0 +1,134 @@
+project(dev_sandbox)
+
+set(SRC
+  main.cpp
+  imgui_renderer.cpp
+  imgui_renderer.hpp
+)
+
+if (${PLATFORM_MAC})
+  append(SRC
+    main.mm
+    ../iphone/Maps/Classes/MetalContextFactory.h
+    ../iphone/Maps/Classes/MetalContextFactory.mm
+  )
+
+  file(GLOB_RECURSE SHADER_SOURCES_FILES ${OMIM_ROOT}/shaders/Metal/*.metal)
+  add_metal_shader_library(shaders_metal
+    ${SHADER_SOURCES_FILES}
+  )
+endif()
+
+if (${PLATFORM_LINUX})
+  append(SRC
+    main_linux.cpp
+  )
+endif()
+
+omim_add_executable(${PROJECT_NAME} MACOSX_BUNDLE ${SRC})
+
+target_link_libraries(${PROJECT_NAME}
+  generator  # For borders::LoadBorders
+  map
+  gflags::gflags
+  glfw
+  imgui
+)
+
+# Installing Vulkan SDK is optional, however without it Vulkan dynamic libraries
+# should be discovered via system paths and validation layers may not be available
+find_package(Vulkan QUIET)
+if (Vulkan_FOUND)
+  message(STATUS "Vulkan found")
+  target_link_libraries(${PROJECT_NAME} Vulkan::Vulkan)
+endif()
+
+if(PLATFORM_MAC)
+  target_embed_metal_shader_libraries(${PROJECT_NAME} shaders_metal)
+endif()
+
+target_compile_definitions(${PROJECT_NAME} PUBLIC GL_SILENCE_DEPRECATION)
+if (PLATFORM_MAC)
+  set_target_properties(${PROJECT_NAME} PROPERTIES XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC YES)
+endif()
+
+if (PLATFORM_LINUX)
+  target_compile_definitions(${PROJECT_NAME} PRIVATE VK_USE_PLATFORM_XLIB_KHR)
+endif()
+
+target_include_directories(${PROJECT_NAME} PUBLIC ${OMIM_ROOT}/3party/glfw/include)
+target_include_directories(${PROJECT_NAME} PUBLIC ${OMIM_ROOT}/3party/imgui)
+
+set(BUNDLE_NAME "OMapsDevSandbox")
+set(BUNDLE_DISPLAY_NAME "Organic Maps: Developer Sandbox")
+
+set_target_properties(${PROJECT_NAME} PROPERTIES OUTPUT_NAME ${BUNDLE_NAME})
+
+set(BUNDLE_EXECUTABLE ${BUNDLE_NAME})
+
+set(BUNDLE_FOLDER ${CMAKE_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${BUNDLE_NAME}.app)
+set(RESOURCES_FOLDER ${BUNDLE_FOLDER}/Contents/Resources)
+set(DATA_DIR ${OMIM_ROOT}/data)
+
+execute_process(
+  COMMAND mkdir -p ${RESOURCES_FOLDER}/shaders_compiler
+)
+
+function(copy_resources)
+  foreach(file ${ARGN})
+    execute_process(
+      COMMAND cp -r ${DATA_DIR}/${file} ${RESOURCES_FOLDER}
+    )
+  endforeach()
+endfunction()
+
+copy_resources(
+  countries-strings
+  resources-default
+  resources-mdpi_light
+  resources-hdpi_light
+  resources-xhdpi_light
+  resources-xxhdpi_light
+  resources-xxxhdpi_light
+  resources-6plus_light
+  vulkan_shaders
+
+  categories.txt
+  categories_cuisines.txt
+  classificator.txt
+  colors.txt
+  countries.txt
+  drules_proto_default_light.bin
+  drules_proto_default_dark.bin
+  drules_proto_vehicle_light.bin
+  drules_proto_vehicle_dark.bin
+  editor.config
+  fonts_blacklist.txt
+  fonts_whitelist.txt
+  packed_polygons.bin
+  patterns.txt
+  transit_colors.txt
+  types.txt
+  unicode_blocks.txt
+  World.mwm
+  WorldCoasts.mwm
+
+  00_NotoNaskhArabic-Regular.ttf
+  00_NotoSansBengali-Regular.ttf
+  00_NotoSansHebrew-Regular.ttf
+  00_NotoSansMalayalam-Regular.ttf
+  00_NotoSansThai-Regular.ttf
+  00_NotoSerifDevanagari-Regular.ttf
+  01_dejavusans.ttf
+  02_droidsans-fallback.ttf
+  03_jomolhari-id-a3d.ttf
+  04_padauk.ttf
+  05_khmeros.ttf
+  06_code2000.ttf
+  07_roboto_medium.ttf
+)
+
+if (NOT PLATFORM_LINUX)
+  # On Linux, ICU data is loaded from the shared library.
+  copy_resources(icudt75l.dat)
+endif()

dev_sandbox/imgui_renderer.cpp

@@ -0,0 +1,257 @@
+#include "imgui_renderer.hpp"
+
+#include "base/logging.hpp"
+#include "base/macros.hpp"
+
+#include <drape_frontend/render_state_extension.hpp>
+
+#include <shaders/program_manager.hpp>
+
+#include <imgui/imgui.h>
+
+#include <cstring>
+#include <limits>
+
+ImguiRenderer::ImguiRenderer()
+  : m_state(df::CreateRenderState(gpu::Program::ImGui, df::DepthLayer::GuiLayer))
+{
+  m_state.SetDepthTestEnabled(false);
+  m_state.SetBlending(dp::Blending(true));
+}
+
+void ImguiRenderer::Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::TextureManager> textureManager,
+                           ref_ptr<gpu::ProgramManager> programManager)
+{
+  std::lock_guard<std::mutex> lock(m_bufferMutex);
+  size_t renderDataIndex = (m_updateIndex + 1) % m_uiDataBuffer.size();
+  UiDataBuffer & dataBuffer = m_uiDataBuffer[renderDataIndex];
+
+  auto gpuProgram = programManager->GetProgram(m_state.GetProgram<gpu::Program>());
+
+  bool needUpdate = true;
+  if (!m_mesh || dataBuffer.m_vertices.size() > m_vertexCount || dataBuffer.m_indices.size() > m_indexCount)
+  {
+    while (dataBuffer.m_vertices.size() > m_vertexCount)
+      m_vertexCount *= 2;
+    while (dataBuffer.m_indices.size() > m_indexCount)
+      m_indexCount *= 2;
+    m_indexCount = std::min(m_indexCount, static_cast<uint32_t>(std::numeric_limits<uint16_t>::max()));
+
+    dataBuffer.m_vertices.resize(m_vertexCount);
+    dataBuffer.m_indices.resize(m_indexCount);
+
+    m_mesh = make_unique_dp<dp::MeshObject>(context, dp::MeshObject::DrawPrimitive::Triangles, "imGui");
+
+    m_mesh->SetBuffer(0, std::move(dataBuffer.m_vertices));
+    m_mesh->SetAttribute("a_position", 0, 0 /* offset */, 2);
+    m_mesh->SetAttribute("a_texCoords", 0, 2 * sizeof(float) /* offset */, 2);
+    m_mesh->SetAttribute("a_color", 0, 4 * sizeof(float) /* offset */, 4);
+    m_mesh->SetIndexBuffer(std::move(dataBuffer.m_indices));
+    m_mesh->Build(context, gpuProgram);
+
+    dataBuffer.m_vertices.clear();
+    dataBuffer.m_indices.clear();
+    needUpdate = false;
+  }
+
+  if (!m_texture)
+  {
+    std::lock_guard<std::mutex> lock(m_textureMutex);
+    if (!m_textureData.empty())
+    {
+      m_texture = make_unique_dp<dp::StaticTexture>();
+      m_texture->Create(context,
+                        dp::Texture::Params{
+                            .m_width = m_textureWidth,
+                            .m_height = m_textureHeight,
+                            .m_format = dp::TextureFormat::RGBA8,
+                            .m_allocator = textureManager->GetTextureAllocator(),
+                        },
+                        m_textureData.data());
+      m_textureData.clear();
+      m_state.SetColorTexture(make_ref(m_texture));
+    }
+    else
+    {
+      // Can't render without texture.
+      return;
+    }
+  }
+
+  if (dataBuffer.m_drawCalls.empty())
+    return;
+
+  if (needUpdate && !dataBuffer.m_vertices.empty() && !dataBuffer.m_indices.empty())
+  {
+    m_mesh->UpdateBuffer(context, 0, dataBuffer.m_vertices);
+    m_mesh->UpdateIndexBuffer(context, dataBuffer.m_indices);
+    dataBuffer.m_vertices.clear();
+    dataBuffer.m_indices.clear();
+  }
+
+  gpu::ImGuiProgramParams const params{.m_projection = m_projection};
+  context->PushDebugLabel("ImGui Rendering");
+  m_mesh->Render(context, gpuProgram, m_state, programManager->GetParamsSetter(), params,
+                 [&, this]()
+                 {
+                   context->SetCullingEnabled(false);
+                   for (auto const & drawCall : dataBuffer.m_drawCalls)
+                   {
+                     uint32_t y = drawCall.clipRect.y;
+                     if (context->GetApiVersion() == dp::ApiVersion::OpenGLES3)
+                       y = dataBuffer.m_height - y - drawCall.clipRect.w;
+                     context->SetScissor(drawCall.clipRect.x, y, drawCall.clipRect.z, drawCall.clipRect.w);
+                     m_mesh->DrawPrimitivesSubsetIndexed(context, drawCall.indexCount, drawCall.startIndex);
+                   }
+                   context->SetCullingEnabled(true);
+                   context->SetScissor(0, 0, dataBuffer.m_width, dataBuffer.m_height);
+                 });
+  context->PopDebugLabel();
+}
+
+void ImguiRenderer::Update(std::function<void()> const & uiCallback)
+{
+  CHECK(uiCallback, ());
+  ImGuiIO & io = ImGui::GetIO();
+  if (!io.Fonts->IsBuilt())
+    io.Fonts->Build();
+  if (!m_texture)
+    UpdateTexture();
+
+  ImGui::NewFrame();
+  uiCallback();
+  ImGui::Render();
+  UpdateBuffers();
+}
+
+void ImguiRenderer::Reset()
+{
+  {
+    std::lock_guard<std::mutex> lock(m_textureMutex);
+    m_texture.reset();
+  }
+
+  {
+    std::lock_guard<std::mutex> lock(m_bufferMutex);
+    m_mesh.reset();
+  }
+}
+
+void ImguiRenderer::UpdateTexture()
+{
+  std::lock_guard<std::mutex> lock(m_textureMutex);
+  unsigned char * pixels;
+  int width, height;
+  ImGui::GetIO().Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
+
+  auto const sizeInBytes = width * height * sizeof(uint32_t);
+  m_textureData.resize(sizeInBytes);
+  memcpy(m_textureData.data(), pixels, sizeInBytes);
+  m_textureWidth = static_cast<uint32_t>(width);
+  m_textureHeight = static_cast<uint32_t>(height);
+}
+
+void ImguiRenderer::UpdateBuffers()
+{
+  UiDataBuffer & dataBuffer = m_uiDataBuffer[m_updateIndex];
+  dataBuffer.m_drawCalls.clear();
+
+  ImDrawData * dd = ImGui::GetDrawData();
+  auto const fbWidth = static_cast<int>(dd->DisplaySize.x * dd->FramebufferScale.x);
+  auto const fbHeight = static_cast<int>(dd->DisplaySize.y * dd->FramebufferScale.y);
+  if (fbWidth <= 0 || fbHeight <= 0 || dd->CmdListsCount == 0 || dd->TotalIdxCount == 0 || dd->TotalVtxCount == 0)
+    return;
+  dataBuffer.m_width = static_cast<uint32_t>(fbWidth);
+  dataBuffer.m_height = static_cast<uint32_t>(fbHeight);
+
+  CHECK(dd->TotalVtxCount <= std::numeric_limits<uint16_t>::max(),
+        ("UI is so complex and now requires 32-bit indices. You need to improve dp::MeshObject or simplify UI"));
+
+  CHECK((ImGui::GetIO().BackendFlags & ImGuiBackendFlags_RendererHasVtxOffset) == 0, ());
+
+  dataBuffer.m_vertices.resize(dd->TotalVtxCount);
+  dataBuffer.m_indices.resize(dd->TotalIdxCount);
+
+  int totalDrawCallsCount = 0;
+  for (int i = 0; i < dd->CmdListsCount; ++i)
+    totalDrawCallsCount += dd->CmdLists[i]->CmdBuffer.Size;
+  dataBuffer.m_drawCalls.reserve(totalDrawCallsCount);
+
+  ImVec2 const clipOff = dd->DisplayPos;
+  ImVec2 const clipScale = dd->FramebufferScale;
+
+  uint32_t vertexOffset = 0;
+  uint32_t indexOffset = 0;
+  for (int i = 0; i < dd->CmdListsCount; ++i)
+  {
+    ImDrawList const * cmdList = dd->CmdLists[i];
+    for (int j = 0; j < cmdList->VtxBuffer.Size; ++j)
+    {
+      dp::Color color(cmdList->VtxBuffer.Data[j].col);
+      dataBuffer.m_vertices[j + vertexOffset] = {
+          .position = {cmdList->VtxBuffer.Data[j].pos.x, cmdList->VtxBuffer.Data[j].pos.y},
+          .texCoords = {cmdList->VtxBuffer.Data[j].uv.x, cmdList->VtxBuffer.Data[j].uv.y},
+          .color = {color.GetAlphaF(), color.GetBlueF(), color.GetGreenF(),
+                    color.GetRedF()}  // Byte order is reversed in imGui
+      };
+    }
+
+    static_assert(sizeof(uint16_t) == sizeof(ImDrawIdx));
+    memcpy(dataBuffer.m_indices.data() + indexOffset, cmdList->IdxBuffer.Data,
+           cmdList->IdxBuffer.Size * sizeof(ImDrawIdx));
+    for (int j = 0; j < cmdList->IdxBuffer.Size; ++j)
+    {
+      uint32_t indexValue = dataBuffer.m_indices[j + indexOffset];
+      indexValue += vertexOffset;
+      CHECK(indexValue <= std::numeric_limits<uint16_t>::max(), ());
+      dataBuffer.m_indices[j + indexOffset] = static_cast<uint16_t>(indexValue);
+    }
+
+    for (int cmdIndex = 0; cmdIndex < cmdList->CmdBuffer.Size; ++cmdIndex)
+    {
+      const ImDrawCmd cmd = cmdList->CmdBuffer[cmdIndex];
+      ImVec2 clipMin((cmd.ClipRect.x - clipOff.x) * clipScale.x, (cmd.ClipRect.y - clipOff.y) * clipScale.y);
+      ImVec2 clipMax((cmd.ClipRect.z - clipOff.x) * clipScale.x, (cmd.ClipRect.w - clipOff.y) * clipScale.y);
+      if (clipMin.x < 0.0f)
+        clipMin.x = 0.0f;
+      if (clipMin.y < 0.0f)
+        clipMin.y = 0.0f;
+      if (clipMax.x > fbWidth)
+        clipMax.x = static_cast<float>(fbWidth);
+      if (clipMax.y > fbHeight)
+        clipMax.y = static_cast<float>(fbHeight);
+      if (clipMax.x <= clipMin.x || clipMax.y <= clipMin.y)
+        continue;
+
+      dataBuffer.m_drawCalls.emplace_back(DrawCall{
+          .indexCount = static_cast<uint32_t>(cmd.ElemCount),
+          .startIndex = static_cast<uint32_t>(indexOffset + cmd.IdxOffset),
+          .clipRect = {static_cast<uint32_t>(clipMin.x), static_cast<uint32_t>(clipMin.y),
+                       static_cast<uint32_t>(clipMax.x - clipMin.x), static_cast<uint32_t>(clipMax.y - clipMin.y)}});
+    }
+
+    vertexOffset += static_cast<uint32_t>(cmdList->VtxBuffer.Size);
+    indexOffset += static_cast<uint32_t>(cmdList->IdxBuffer.Size);
+  }
+  CHECK(vertexOffset == dataBuffer.m_vertices.size(), ());
+  CHECK(indexOffset == dataBuffer.m_indices.size(), ());
+
+  {
+    std::lock_guard<std::mutex> lock(m_bufferMutex);
+
+    // Projection
+    float const left = dd->DisplayPos.x;
+    float const right = dd->DisplayPos.x + dd->DisplaySize.x;
+    float const top = dd->DisplayPos.y;
+    float const bottom = dd->DisplayPos.y + dd->DisplaySize.y;
+    m_projection[0][0] = 2.0f / (right - left);
+    m_projection[1][1] = 2.0f / (top - bottom);
+    m_projection[2][2] = -1.0f;
+    m_projection[3][3] = 1.0f;
+    m_projection[0][3] = -(right + left) / (right - left);
+    m_projection[1][3] = -(top + bottom) / (top - bottom);
+
+    // Swap buffers
+    m_updateIndex = (m_updateIndex + 1) % m_uiDataBuffer.size();
+  }
+}

dev_sandbox/imgui_renderer.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+#include "drape/glsl_types.hpp"
+#include "drape/graphics_context.hpp"
+#include "drape/mesh_object.hpp"
+#include "drape/pointers.hpp"
+#include "drape/render_state.hpp"
+#include "drape/static_texture.hpp"
+#include "drape/texture_manager.hpp"
+
+#include <array>
+#include <cstdint>
+#include <functional>
+#include <mutex>
+#include <vector>
+
+class ImguiRenderer
+{
+public:
+  ImguiRenderer();
+  void Render(ref_ptr<dp::GraphicsContext> context, 
+              ref_ptr<dp::TextureManager> textureManager,
+              ref_ptr<gpu::ProgramManager> programManager);
+  void Update(std::function<void()> const & uiCallback);
+  void Reset();
+
+private:
+  void UpdateTexture();
+  void UpdateBuffers();
+
+  struct ImguiVertex
+  {
+    glsl::vec2 position;
+    glsl::vec2 texCoords;
+    glsl::vec4 color;
+  };
+  static_assert(sizeof(ImguiVertex) == 2 * sizeof(glsl::vec4));
+
+  struct DrawCall
+  {
+    uint32_t indexCount = 0;
+    uint32_t startIndex = 0;
+    glsl::uvec4 clipRect{};
+  };
+
+  drape_ptr<dp::MeshObject> m_mesh;
+  uint32_t m_vertexCount = 2000;
+  uint32_t m_indexCount = 3000;
+
+  drape_ptr<dp::StaticTexture> m_texture;
+  std::vector<unsigned char> m_textureData;
+  uint32_t m_textureWidth = 0;
+  uint32_t m_textureHeight = 0;
+
+  dp::RenderState m_state;
+
+  struct UiDataBuffer
+  {
+    std::vector<ImguiVertex> m_vertices;
+    std::vector<uint16_t> m_indices;
+    std::vector<DrawCall> m_drawCalls;
+    uint32_t m_width;
+    uint32_t m_height;
+  };
+  std::array<UiDataBuffer, 2> m_uiDataBuffer;
+  size_t m_updateIndex = 0;
+
+  glsl::mat4 m_projection;
+
+  std::mutex m_bufferMutex;
+  std::mutex m_textureMutex;
+};

dev_sandbox/main.cpp

@@ -0,0 +1,683 @@
+#include "dev_sandbox/imgui_renderer.hpp"
+
+#include "map/framework.hpp"
+
+#include "platform/platform.hpp"
+#include "platform/settings.hpp"
+
+#include "coding/reader.hpp"
+
+#include "base/logging.hpp"
+#include "base/macros.hpp"
+
+#include "std/target_os.hpp"
+
+#include <chrono>
+#include <functional>
+#include <mutex>
+#include <optional>
+#include <sstream>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <gflags/gflags.h>
+
+#if defined(OMIM_OS_WINDOWS)
+#define GLFW_EXPOSE_NATIVE_WIN32
+#elif defined(OMIM_OS_LINUX)
+#define GLFW_EXPOSE_NATIVE_X11
+#elif defined(OMIM_OS_MAC)
+#define GLFW_EXPOSE_NATIVE_COCOA
+#else
+#error Unsupported plaform
+#endif
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
+#include <GLFW/glfw3native.h>
+#include <imgui/backends/imgui_impl_glfw.h>
+#include <imgui/imgui.h>
+
+DEFINE_string(data_path, "", "Path to data directory.");
+DEFINE_string(log_abort_level, base::ToString(base::GetDefaultLogAbortLevel()),
+              "Log messages severity that causes termination.");
+DEFINE_string(resources_path, "", "Path to resources directory.");
+DEFINE_string(lang, "", "Device language.");
+
+#if defined(OMIM_OS_MAC) || defined(OMIM_OS_LINUX)
+drape_ptr<dp::GraphicsContextFactory> CreateContextFactory(GLFWwindow * window, dp::ApiVersion api, m2::PointU size);
+void PrepareDestroyContextFactory(ref_ptr<dp::GraphicsContextFactory> contextFactory);
+void OnCreateDrapeEngine(GLFWwindow * window, dp::ApiVersion api, ref_ptr<dp::GraphicsContextFactory> contextFactory);
+void UpdateContentScale(GLFWwindow * window, float scale);
+void UpdateSize(ref_ptr<dp::GraphicsContextFactory> contextFactory, int w, int h);
+#endif
+
+#if defined(OMIM_OS_LINUX)
+// Workaround for storage::Status compilation issue:
+// /usr/include/X11/Xlib.h:83:16: note: expanded from macro 'Status'
+#undef Status
+#endif
+
+namespace
+{
+bool ValidateLogAbortLevel(char const * flagname, std::string const & value)
+{
+  if (auto level = base::FromString(value); !level)
+  {
+    std::cerr << "Invalid value for --" << flagname << ": " << value << ", must be one of: ";
+    auto const & names = base::GetLogLevelNames();
+    for (size_t i = 0; i < names.size(); ++i)
+    {
+      if (i != 0)
+        std::cerr << ", ";
+      std::cerr << names[i];
+    }
+    std::cerr << '\n';
+    return false;
+  }
+  return true;
+}
+
+bool const g_logAbortLevelDummy = gflags::RegisterFlagValidator(&FLAGS_log_abort_level, &ValidateLogAbortLevel);
+
+void errorCallback(int error, char const * description) { LOG(LERROR, ("GLFW (", error, "):", description)); }
+
+struct WindowHandlers
+{
+  std::function<void(int w, int h)> onResize;
+  std::function<void(double x, double y, int button, int action, int mods)> onMouseButton;
+  std::function<void(double x, double y)> onMouseMove;
+  std::function<void(double x, double y, double xOffset, double yOffset)> onScroll;
+  std::function<void(int key, int scancode, int action, int mods)> onKeyboardButton;
+  std::function<void(float xscale, float yscale)> onContentScale;
+} handlers;
+
+df::Touch GetTouch(double x, double y)
+{
+  return df::Touch{.m_location = m2::PointF(static_cast<float>(x), static_cast<float>(y)), .m_id = 0};
+}
+
+df::Touch GetSymmetricalTouch(Framework & framework, df::Touch const & touch)
+{
+  m2::PointD const pixelCenter = framework.GetVisiblePixelCenter();
+  m2::PointD const symmetricalLocation = pixelCenter + pixelCenter - m2::PointD(touch.m_location);
+
+  df::Touch result;
+  result.m_id = touch.m_id + 1;
+  result.m_location = symmetricalLocation;
+
+  return result;
+}
+
+df::TouchEvent GetTouchEvent(Framework & framework, double x, double y, int mods, df::TouchEvent::ETouchType type)
+{
+  df::TouchEvent event;
+  event.SetTouchType(type);
+  event.SetFirstTouch(GetTouch(x, y));
+  if (mods & GLFW_MOD_SUPER)
+    event.SetSecondTouch(GetSymmetricalTouch(framework, event.GetFirstTouch()));
+  return event;
+}
+
+void FormatMapSize(uint64_t sizeInBytes, std::string & units, size_t & sizeToDownload)
+{
+  int const mbInBytes = 1024 * 1024;
+  int const kbInBytes = 1024;
+  if (sizeInBytes > mbInBytes)
+  {
+    sizeToDownload = (sizeInBytes + mbInBytes - 1) / mbInBytes;
+    units = "MB";
+  }
+  else if (sizeInBytes > kbInBytes)
+  {
+    sizeToDownload = (sizeInBytes + kbInBytes - 1) / kbInBytes;
+    units = "KB";
+  }
+  else
+  {
+    sizeToDownload = sizeInBytes;
+    units = "B";
+  }
+}
+
+std::string_view GetMyPoisitionText(location::EMyPositionMode mode)
+{
+  switch(mode)
+  {
+  case location::EMyPositionMode::PendingPosition: return "Pending";
+  case location::EMyPositionMode::NotFollowNoPosition: return "No position";
+  case location::EMyPositionMode::NotFollow: return "Not follow";
+  case location::EMyPositionMode::Follow: return "Follow";
+  case location::EMyPositionMode::FollowAndRotate: return "Follow and Rotate";
+  }
+  return "";
+}
+
+dp::ApiVersion GetApiVersion(char const * apiLabel)
+{
+  std::string_view v(apiLabel);
+  if (v == "Metal") return dp::ApiVersion::Metal;
+  if (v == "Vulkan") return dp::ApiVersion::Vulkan;
+  if (v == "OpenGL") return  dp::ApiVersion::OpenGLES3;
+  return dp::ApiVersion::Invalid;
+}
+
+#if defined(OMIM_OS_LINUX)
+class LinuxGuiThread : public base::TaskLoop
+{
+public:
+  PushResult Push(Task && task) override
+  {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_tasks.emplace_back(std::move(task));
+    return {true, base::TaskLoop::kNoId};
+  }
+
+  PushResult Push(Task const & task) override
+  {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_tasks.emplace_back(task);
+    return {true, base::TaskLoop::kNoId};
+  }
+
+  void ExecuteTasks() 
+  {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    for (auto & task : m_tasks)
+      task();
+    m_tasks.clear();
+  }
+
+private:
+  std::vector<Task> m_tasks;
+  std::mutex m_mutex;
+};
+#endif
+}  // namespace
+
+int main(int argc, char * argv[])
+{
+  // Our double parsing code (base/string_utils.hpp) needs dots as a floating point delimiters, not commas.
+  // TODO: Refactor our doubles parsing code to use locale-independent delimiters.
+  // For example, https://github.com/google/double-conversion can be used.
+  // See http://dbaron.org/log/20121222-locale for more details.
+  (void)::setenv("LC_NUMERIC", "C", 1);
+
+  Platform & platform = GetPlatform();
+
+  LOG(LINFO, ("Organic Maps: Developer Sandbox", platform.Version(), "detected CPU cores:", platform.CpuCores()));
+
+  gflags::SetUsageMessage("Developer Sandbox.");
+  gflags::SetVersionString(platform.Version());
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+
+  if (!FLAGS_resources_path.empty())
+    platform.SetResourceDir(FLAGS_resources_path);
+  if (!FLAGS_data_path.empty())
+    platform.SetWritableDirForTests(FLAGS_data_path);
+
+  if (auto const logLevel = base::FromString(FLAGS_log_abort_level); logLevel)
+    base::g_LogAbortLevel = *logLevel;
+  else
+    LOG(LCRITICAL, ("Invalid log level:", FLAGS_log_abort_level));
+
+#if defined(OMIM_OS_LINUX)
+  auto guiThread = std::make_unique<LinuxGuiThread>();
+  auto guiThreadPtr = guiThread.get();
+  platform.SetGuiThread(std::move(guiThread));
+#endif
+
+  // Init GLFW.
+  glfwSetErrorCallback(errorCallback);
+  if (!glfwInit())
+  {
+    return -1;
+  }
+  glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+#if defined(OMIM_OS_WINDOWS)
+  glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_TRUE);
+#endif
+  auto monitor = glfwGetPrimaryMonitor();
+  auto mode = glfwGetVideoMode(monitor);
+  GLFWwindow * window =
+      glfwCreateWindow(mode->width, mode->height, "Organic Maps: Developer Sandbox", nullptr, nullptr);
+  int fbWidth = 0, fbHeight = 0;
+  glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
+  float xs = 1.0f, ys = 1.0f;
+  glfwGetWindowContentScale(window, &xs, &ys);
+  float visualScale = std::max(xs, ys);
+  glfwSetGamma(monitor, 1.0f);
+
+  IMGUI_CHECKVERSION();
+  ImGui::CreateContext();
+  ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
+  ImGui::StyleColorsClassic();
+  glfwMaximizeWindow(window);
+
+  platform.SetupMeasurementSystem();
+
+  bool outvalue;
+  if (!settings::Get(settings::kDeveloperMode, outvalue))
+    settings::Set(settings::kDeveloperMode, true);
+
+  if (!FLAGS_lang.empty())
+    (void)::setenv("LANGUAGE", FLAGS_lang.c_str(), 1);
+
+  FrameworkParams frameworkParams;
+  Framework framework(frameworkParams);
+
+  ImguiRenderer imguiRenderer;
+  Framework::DrapeCreationParams drapeParams{
+#if defined(OMIM_OS_MAC)
+      .m_apiVersion = dp::ApiVersion::Metal,
+#else
+      .m_apiVersion = dp::ApiVersion::Vulkan,
+#endif
+      .m_visualScale = visualScale,
+      .m_surfaceWidth = fbWidth,
+      .m_surfaceHeight = fbHeight,
+      .m_renderInjectionHandler = [&](ref_ptr<dp::GraphicsContext> context, 
+                                      ref_ptr<dp::TextureManager> textureManager,
+                                      ref_ptr<gpu::ProgramManager> programManager,
+                                      bool shutdown)
+      {
+        if (shutdown)
+          imguiRenderer.Reset();
+        else
+          imguiRenderer.Render(context, textureManager, programManager);
+      }};
+  gui::Skin guiSkin(gui::ResolveGuiSkinFile("default"), visualScale);
+  guiSkin.Resize(fbWidth, fbHeight);
+  guiSkin.ForEach([&](gui::EWidget widget, gui::Position const & pos) { drapeParams.m_widgetsInitInfo[widget] = pos; });
+  drapeParams.m_widgetsInitInfo[gui::WIDGET_SCALE_FPS_LABEL] = gui::Position(dp::LeftTop);
+
+  drape_ptr<dp::GraphicsContextFactory> contextFactory;
+  auto CreateDrapeEngine = [&](dp::ApiVersion version)
+  {
+    drapeParams.m_apiVersion = version;
+    drapeParams.m_visualScale = visualScale;
+    drapeParams.m_surfaceWidth = fbWidth;
+    drapeParams.m_surfaceHeight = fbHeight;
+    contextFactory = CreateContextFactory(window, drapeParams.m_apiVersion,
+                                          m2::PointU(static_cast<uint32_t>(drapeParams.m_surfaceWidth),
+                                          static_cast<uint32_t>(drapeParams.m_surfaceHeight)));
+    auto params = drapeParams;
+    framework.CreateDrapeEngine(make_ref(contextFactory), std::move(params));
+    OnCreateDrapeEngine(window, version, make_ref(contextFactory));
+    framework.SetRenderingEnabled(nullptr);
+  };
+  CreateDrapeEngine(drapeParams.m_apiVersion);
+
+  auto DestroyDrapeEngine = [&]()
+  {
+    framework.SetRenderingDisabled(true);
+    framework.DestroyDrapeEngine();
+    PrepareDestroyContextFactory(make_ref(contextFactory));
+    contextFactory.reset();
+  };
+
+  // Process resizing.
+  handlers.onResize = [&](int w, int h)
+  {
+    fbWidth = w;
+    fbHeight = h;
+    if (fbWidth > 0 && fbHeight > 0)
+    {
+      UpdateSize(make_ref(contextFactory), fbWidth, fbHeight);
+      framework.OnSize(fbWidth, fbHeight);
+
+      guiSkin.Resize(w, h);
+      gui::TWidgetsLayoutInfo layout;
+      guiSkin.ForEach([&layout](gui::EWidget w, gui::Position const & pos) { layout[w] = pos.m_pixelPivot; });
+      framework.SetWidgetLayout(std::move(layout));
+      framework.MakeFrameActive();
+    }
+  };
+  glfwSetFramebufferSizeCallback(window, [](GLFWwindow * wnd, int w, int h) { handlers.onResize(w, h); });
+
+  // Process change content scale.
+  handlers.onContentScale = [&](float xscale, float yscale)
+  {
+    visualScale = std::max(xscale, yscale);
+    framework.UpdateVisualScale(visualScale);
+
+    int w = 0, h = 0;
+    glfwGetWindowSize(window, &w, &h);
+#if defined(OMIM_OS_MAC)
+    w *= xscale;
+    h *= yscale;
+#endif
+
+    if (w != fbWidth || h != fbHeight)
+    {
+#if defined(OMIM_OS_MAC)
+      UpdateContentScale(window, xscale);
+#endif
+      fbWidth = w;
+      fbHeight = h;
+      UpdateSize(make_ref(contextFactory), fbWidth, fbHeight);
+      framework.OnSize(fbWidth, fbHeight);
+    }
+  };
+  glfwSetWindowContentScaleCallback(window, [](GLFWwindow *, float xscale, float yscale) 
+  { 
+    handlers.onContentScale(xscale, yscale); 
+  });
+
+  // Location handler
+  std::optional<ms::LatLon> lastLatLon;
+  bool bearingEnabled = false;
+  float bearing = 0.0f;
+  auto setUserLocation = [&]()
+  {
+    if (lastLatLon)
+    {
+      framework.OnLocationUpdate(
+          location::GpsInfo{.m_source = location::EUser,
+                            .m_timestamp = static_cast<double>(std::chrono::duration_cast<std::chrono::milliseconds>(
+                                                                   std::chrono::system_clock::now().time_since_epoch())
+                                                                   .count()) /
+                                           1000,
+                            .m_latitude = lastLatLon->m_lat,
+                            .m_longitude = lastLatLon->m_lon,
+                            .m_horizontalAccuracy = 10,
+                            .m_bearing = bearingEnabled ? bearing : -1.0f});
+      if (bearingEnabled)
+      {
+        framework.OnCompassUpdate(location::CompassInfo{.m_bearing = base::DegToRad(bearing)});
+      }
+    }
+  };
+
+  // Download maps handler
+  std::string downloadButtonLabel;
+  std::string retryButtonLabel;
+  std::string downloadStatusLabel;
+  storage::CountryId lastCountry;
+  auto const onCountryChanged = [&](storage::CountryId const & countryId)
+  {
+    downloadButtonLabel.clear();
+    retryButtonLabel.clear();
+    downloadStatusLabel.clear();
+    lastCountry = countryId;
+    // Called by Framework in World zoom level.
+    if (countryId.empty())
+      return;
+
+    auto const & storage = framework.GetStorage();
+    auto status = storage.CountryStatusEx(countryId);
+    auto const & countryName = countryId;
+
+    if (status == storage::Status::NotDownloaded)
+    {
+      std::string units;
+      size_t sizeToDownload = 0;
+      FormatMapSize(storage.CountrySizeInBytes(countryId).second, units, sizeToDownload);
+      std::stringstream str;
+      str << "Download (" << countryName << ") " << sizeToDownload << units;
+      downloadButtonLabel = str.str();
+    }
+    else if (status == storage::Status::InQueue)
+    {
+      std::stringstream str;
+      str << countryName << " is waiting for downloading";
+      downloadStatusLabel = str.str();
+    }
+    else if (status != storage::Status::Downloading && status != storage::Status::OnDisk &&
+             status != storage::Status::OnDiskOutOfDate)
+    {
+      std::stringstream str;
+      str << "Retry to download " << countryName;
+      retryButtonLabel = str.str();
+    }
+  };
+  framework.SetCurrentCountryChangedListener(onCountryChanged);
+
+  framework.GetStorage().Subscribe(
+      [&](storage::CountryId const & countryId)
+      {
+        // Storage also calls notifications for parents, but we are interested in leafs only.
+        if (framework.GetStorage().IsLeaf(countryId))
+          onCountryChanged(countryId);
+      },
+      [&](storage::CountryId const & countryId, downloader::Progress const & progress)
+      {
+        std::stringstream str;
+        str << "Downloading (" << countryId << ") " << (progress.m_bytesDownloaded * 100 / progress.m_bytesTotal)
+            << "%";
+        downloadStatusLabel = str.str();
+        framework.MakeFrameActive();
+      });
+
+  // Handle mouse buttons.
+  bool touchActive = false;
+  int touchMods = 0;
+  bool setUpLocationByLeftClick = false;
+  handlers.onMouseButton = [&](double x, double y, int button, int action, int mods)
+  {
+#if defined(OMIM_OS_LINUX)
+    ImGui::GetIO().MousePos = ImVec2(x / visualScale, y / visualScale);
+#endif
+    if (ImGui::GetIO().WantCaptureMouse)
+    {
+      framework.MakeFrameActive();
+      return;
+    }
+
+#if defined(OMIM_OS_MAC)
+    x *= visualScale;
+    y *= visualScale;
+#endif
+    lastLatLon = mercator::ToLatLon(framework.PtoG(m2::PointD(x, y)));
+
+    if (setUpLocationByLeftClick)
+    {
+      setUserLocation();
+      return;
+    }
+
+    if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS)
+    {
+      framework.TouchEvent(GetTouchEvent(framework, x, y, mods, df::TouchEvent::TOUCH_DOWN));
+      touchActive = true;
+      touchMods = mods;
+    }
+
+    if (touchActive && action == GLFW_RELEASE)
+    {
+      framework.TouchEvent(GetTouchEvent(framework, x, y, 0, df::TouchEvent::TOUCH_UP));
+      touchActive = false;
+      touchMods = 0;
+    }
+  };
+  glfwSetMouseButtonCallback(window,
+                             [](GLFWwindow * wnd, int button, int action, int mods)
+                             {
+                               double x, y;
+                               glfwGetCursorPos(wnd, &x, &y);
+                               handlers.onMouseButton(x, y, button, action, mods);
+                             });
+
+  // Handle mouse moving.
+  handlers.onMouseMove = [&](double x, double y)
+  {
+#if defined(OMIM_OS_LINUX)
+    ImGui::GetIO().MousePos = ImVec2(x / visualScale, y / visualScale);
+#endif
+    if (ImGui::GetIO().WantCaptureMouse)
+      framework.MakeFrameActive();
+
+    if (touchActive)
+    {
+#if defined(OMIM_OS_MAC)
+      x *= visualScale;
+      y *= visualScale;
+#endif
+      framework.TouchEvent(
+          GetTouchEvent(framework, x, y, touchMods, df::TouchEvent::TOUCH_MOVE));
+    }
+  };
+  glfwSetCursorPosCallback(window, [](GLFWwindow *, double x, double y) 
+  { 
+    handlers.onMouseMove(x, y); 
+  });
+
+  // Handle scroll.
+  handlers.onScroll = [&](double x, double y, double xOffset, double yOffset)
+  {
+#if defined(OMIM_OS_LINUX)
+    ImGui::GetIO().MousePos = ImVec2(x / visualScale, y / visualScale);
+#endif
+    if (ImGui::GetIO().WantCaptureMouse)
+    {
+      framework.MakeFrameActive();
+      return;
+    }
+
+#if defined(OMIM_OS_MAC)
+    x *= visualScale;
+    y *= visualScale;
+#endif
+    constexpr double kSensitivity = 0.01;
+    double const factor = yOffset * kSensitivity;
+    framework.Scale(exp(factor), m2::PointD(x, y), false);
+  };
+  glfwSetScrollCallback(window,
+                        [](GLFWwindow * wnd, double xoffset, double yoffset)
+                        {
+                          double x, y;
+                          glfwGetCursorPos(wnd, &x, &y);
+                          handlers.onScroll(x, y, xoffset, yoffset);
+                        });
+
+  // Keys.
+  handlers.onKeyboardButton = [&](int key, int scancode, int action, int mods) {};
+  glfwSetKeyCallback(window, [](GLFWwindow *, int key, int scancode, int action, int mods)
+  {
+    handlers.onKeyboardButton(key, scancode, action, mods);
+  });
+
+  // imGui UI
+  bool enableDebugRectRendering = false;
+  bool enableAA = false;
+  auto imGuiUI = [&]()
+  {
+    ImGui::SetNextWindowPos(ImVec2(5, 20), ImGuiCond_Appearing);
+    ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
+
+    // Drape controls
+    char const * apiLabels[] = {
+#if defined(OMIM_OS_MAC)
+      "Metal",
+      "Vulkan",
+      "OpenGL"
+#elif defined(OMIM_OS_LINUX)
+      "Vulkan",
+      "OpenGL"
+#endif
+    };
+    static int currentAPI = 0;
+    if (ImGui::Combo("API", &currentAPI, apiLabels, IM_ARRAYSIZE(apiLabels)))
+    {
+      auto const apiVersion = GetApiVersion(apiLabels[currentAPI]);
+      if (framework.GetDrapeEngine()->GetApiVersion() != apiVersion)
+      {
+        DestroyDrapeEngine();
+        CreateDrapeEngine(apiVersion);
+      }
+    }
+    if (ImGui::Checkbox("Debug rect rendering", &enableDebugRectRendering))
+      framework.EnableDebugRectRendering(enableDebugRectRendering);
+    if (ImGui::Checkbox("Antialiasing", &enableAA))
+      framework.GetDrapeEngine()->SetPosteffectEnabled(df::PostprocessRenderer::Antialiasing, enableAA);
+    ImGui::NewLine();
+    ImGui::Separator();
+    ImGui::NewLine();
+
+    // Map controls
+    if (ImGui::Button("Scale +"))
+      framework.Scale(Framework::SCALE_MAG, true);
+    ImGui::SameLine();
+    if (ImGui::Button("Scale -"))
+      framework.Scale(Framework::SCALE_MIN, true);
+    ImGui::Checkbox("Set up location by left click", &setUpLocationByLeftClick);
+    if (setUpLocationByLeftClick)
+    {
+      if (ImGui::Checkbox("Bearing", &bearingEnabled))
+        setUserLocation();
+      ImGui::SameLine();
+      if (ImGui::SliderFloat(" ", &bearing, 0.0f, 360.0f, "%.1f"))
+        setUserLocation();
+    }
+    ImGui::Text("My positon mode: %s", GetMyPoisitionText(framework.GetMyPositionMode()).data());
+    if (ImGui::Button("Next Position Mode"))
+      framework.SwitchMyPositionNextMode();
+    ImGui::NewLine();
+    ImGui::Separator();
+    ImGui::NewLine();
+
+    // No downloading on Linux at the moment, need to implement http_thread without Qt.
+#if !defined(OMIM_OS_LINUX)
+    // Download controls
+    if (!downloadButtonLabel.empty())
+    {
+      if (ImGui::Button(downloadButtonLabel.c_str()))
+        framework.GetStorage().DownloadNode(lastCountry);
+    }
+    if (!retryButtonLabel.empty())
+    {
+      if (ImGui::Button(retryButtonLabel.c_str()))
+        framework.GetStorage().RetryDownloadNode(lastCountry);
+    }
+    if (!downloadStatusLabel.empty())
+      ImGui::Text("%s", downloadStatusLabel.c_str());
+    if (!downloadButtonLabel.empty() || !retryButtonLabel.empty() || !downloadStatusLabel.empty())
+    {
+      ImGui::NewLine();
+      ImGui::Separator();
+      ImGui::NewLine();
+    }
+#endif
+
+    ImGui::End();
+  };
+
+  ImGui_ImplGlfw_InitForOther(window, true);
+
+  // Main loop.
+  while (!glfwWindowShouldClose(window))
+  {
+    glfwPollEvents();
+
+#if defined(OMIM_OS_LINUX)
+    guiThreadPtr->ExecuteTasks();
+#endif
+
+    // Render imGui UI
+    ImGui_ImplGlfw_NewFrame();
+    ImGuiIO& io = ImGui::GetIO();
+#if defined(OMIM_OS_LINUX)
+    // Apply correct visual scale on Linux
+    // In glfw for Linux, window size and framebuffer size are the same,
+    // even if visual scale is not 1.0. It's different from behaviour on Mac.
+    io.DisplaySize = ImVec2(fbWidth / visualScale, fbHeight / visualScale);
+    io.DisplayFramebufferScale = ImVec2(visualScale, visualScale);
+    double mouseX, mouseY;
+    glfwGetCursorPos(window, &mouseX, &mouseY);
+    io.AddMousePosEvent((float)mouseX / visualScale, (float)mouseY / visualScale);
+#endif
+    io.IniFilename = nullptr;
+    imguiRenderer.Update(imGuiUI);
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000 / 30));
+  }
+
+  framework.EnterBackground();
+  DestroyDrapeEngine();
+
+  ImGui_ImplGlfw_Shutdown();
+  ImGui::DestroyContext();
+
+  glfwDestroyWindow(window);
+  glfwTerminate();
+  return 0;
+}

dev_sandbox/main.mm

@@ -0,0 +1,370 @@
+#include "iphone/Maps/Classes/MetalContextFactory.h"
+
+#include "drape/gl_functions.hpp"
+#include "drape/oglcontext.hpp"
+#include "drape/metal/metal_base_context.hpp"
+#include "drape/vulkan/vulkan_context_factory.hpp"
+
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
+
+#if __APPLE__
+#define GLFW_EXPOSE_NATIVE_COCOA
+#else
+#error Unsupported OS
+#endif
+#include <GLFW/glfw3native.h>
+
+#import <AppKit/NSOpenGL.h>
+#import <Cocoa/Cocoa.h>
+#import <Metal/Metal.h>
+#import <QuartzCore/CAMetalLayer.h>
+
+#include <vulkan/vulkan_macos.h>
+
+#include <atomic>
+#include <memory>
+
+class MacOSVulkanContextFactory : public dp::vulkan::VulkanContextFactory
+{
+public:
+  MacOSVulkanContextFactory()
+    : dp::vulkan::VulkanContextFactory(1, 33, false) {}
+
+  void SetSurface(CAMetalLayer *layer)
+  {
+    VkMacOSSurfaceCreateInfoMVK createInfo = {
+      .sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK,
+      .flags = 0,
+      .pView = static_cast<const void *>(CFBridgingRetain(layer)),
+    };
+
+    VkResult statusCode;
+    CHECK(vkCreateMacOSSurfaceMVK, ());
+    statusCode = vkCreateMacOSSurfaceMVK(m_vulkanInstance, &createInfo, nullptr,
+                                          &m_surface);
+    if (statusCode != VK_SUCCESS)
+    {
+      LOG_ERROR_VK_CALL(vkCreateMacOSSurfaceMVK, statusCode);
+      return;
+    }
+
+    uint32_t const renderingQueueIndex = m_drawContext->GetRenderingQueueFamilyIndex();
+    VkBool32 supportsPresent;
+    statusCode = vkGetPhysicalDeviceSurfaceSupportKHR(m_gpu, renderingQueueIndex, m_surface, &supportsPresent);
+    if (statusCode != VK_SUCCESS)
+    {
+      LOG_ERROR_VK_CALL(vkGetPhysicalDeviceSurfaceSupportKHR, statusCode);
+      return;
+    }
+    CHECK_EQUAL(supportsPresent, VK_TRUE, ());
+
+    CHECK(QuerySurfaceSize(), ());
+
+    if (m_drawContext)
+      m_drawContext->SetSurface(m_surface, m_surfaceFormat, m_surfaceCapabilities);
+  }
+
+  void ResetSurface()
+  {
+    if (m_drawContext)
+      m_drawContext->ResetSurface(false);
+
+    vkDestroySurfaceKHR(m_vulkanInstance, m_surface, nullptr);
+  }
+};
+
+class MacGLContext : public dp::OGLContext
+{
+public:
+  MacGLContext(MacGLContext * contextToShareWith)
+    : m_viewSet(false)
+  {
+    NSOpenGLPixelFormatAttribute attributes[] = {
+      NSOpenGLPFAAccelerated,
+      NSOpenGLPFAOpenGLProfile,
+      NSOpenGLProfileVersion4_1Core,
+      NSOpenGLPFADoubleBuffer,
+      NSOpenGLPFAColorSize,
+      24,
+      NSOpenGLPFAAlphaSize,
+      8,
+      NSOpenGLPFADepthSize,
+      24,
+      NSOpenGLPFAStencilSize,
+      8,
+      0
+    };
+    m_pixelFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];
+    CHECK(m_pixelFormat, ("Pixel format is not found"));
+    m_context = [[NSOpenGLContext alloc] initWithFormat:m_pixelFormat 
+                                           shareContext:(contextToShareWith ? contextToShareWith->m_context : nil)];
+    int interval = 1;
+    [m_context getValues:&interval forParameter:NSOpenGLContextParameterSwapInterval];
+  }
+
+  ~MacGLContext()
+  {
+    @autoreleasepool {
+      [m_context clearDrawable];
+      m_pixelFormat = nil;
+      m_context = nil;
+    }
+  }
+
+  bool BeginRendering() override { return m_viewSet; }
+
+  void Present() override
+  {
+    if (m_viewSet)
+    {
+      std::lock_guard<std::mutex> lock(m_updateSizeMutex);
+      [m_context flushBuffer];
+    }
+  }
+
+  void MakeCurrent() override
+  {
+    [m_context makeCurrentContext];
+  }
+
+  void DoneCurrent() override
+  {
+    [NSOpenGLContext clearCurrentContext];
+  }
+
+  void SetFramebuffer(ref_ptr<dp::BaseFramebuffer> framebuffer) override
+  {
+    if (framebuffer)
+      framebuffer->Bind();
+    else
+      GLFunctions::glBindFramebuffer(0);
+  }
+
+  void SetView(NSView* view)
+  {
+    [m_context setView: view];
+    [m_context update];
+    m_viewSet = true;
+  }
+
+  void UpdateSize(int w, int h)
+  {
+    std::lock_guard<std::mutex> lock(m_updateSizeMutex);
+    [m_context update];
+  }
+
+private:
+  NSOpenGLPixelFormat * m_pixelFormat = nil;
+  NSOpenGLContext* m_context = nil;
+  std::atomic<bool> m_viewSet;
+
+  std::mutex m_updateSizeMutex;
+};
+
+class MacGLContextFactory: public dp::GraphicsContextFactory
+{
+public:
+  dp::GraphicsContext * GetDrawContext() override
+  {
+    bool needNotify = false;
+    {
+      std::lock_guard<std::mutex> lock(m_contextAccess);
+      if (m_drawContext == nullptr)
+      {
+        m_drawContext = std::make_unique<MacGLContext>(m_uploadContext.get());
+        needNotify = true;
+      }
+    }
+    if (needNotify)
+      NotifyView();
+
+    std::lock_guard<std::mutex> lock(m_contextAccess);
+    return m_drawContext.get();
+  }
+
+  dp::GraphicsContext * GetResourcesUploadContext() override
+  {
+    std::lock_guard<std::mutex> lock(m_contextAccess);
+    if (m_uploadContext == nullptr)
+      m_uploadContext = std::make_unique<MacGLContext>(m_drawContext.get());
+    return m_uploadContext.get();
+  }
+
+  void WaitForInitialization(dp::GraphicsContext *) override
+  {
+    std::unique_lock<std::mutex> lock(m_initializationMutex);
+    if (m_isInitialized)
+      return;
+
+    m_initializationCounter++;
+    if (m_initializationCounter >= kGLThreadsCount)
+    {
+      m_isInitialized = true;
+      m_initializationCondition.notify_all();
+    }
+    else
+    {
+      m_initializationCondition.wait(lock, [this] { return m_isInitialized; });
+    }
+  }
+
+  bool IsDrawContextCreated() const override
+  { 
+    std::lock_guard<std::mutex> lock(m_contextAccess);
+    return m_drawContext != nullptr; 
+  }
+
+  bool IsUploadContextCreated() const override 
+  {
+    std::lock_guard<std::mutex> lock(m_contextAccess);
+    return m_uploadContext != nullptr;
+  }
+
+  void SetView(NSView* view)
+  {
+    bool needWait;
+    {
+      std::lock_guard<std::mutex> lock(m_contextAccess);
+      needWait = (m_drawContext == nullptr);
+    }
+    if (needWait)
+    {
+      std::unique_lock<std::mutex> lock(m_viewSetMutex);
+      m_viewSetCondition.wait(lock, [this] { return m_viewSet; });
+    }
+
+    std::lock_guard<std::mutex> lock(m_contextAccess);
+    CHECK(m_drawContext, ());
+    m_drawContext->SetView(view);
+  }
+
+  void UpdateSize(int w, int h)
+  {
+    std::lock_guard<std::mutex> lock(m_contextAccess);
+    if (m_drawContext)
+      m_drawContext->UpdateSize(w, h);
+  }
+  
+private:
+  void NotifyView()
+  {
+    std::lock_guard<std::mutex> lock(m_viewSetMutex);
+    m_viewSet = true;
+    m_viewSetCondition.notify_all();
+  }
+
+  static size_t constexpr kGLThreadsCount = 2;
+
+  std::unique_ptr<MacGLContext> m_drawContext;
+  std::unique_ptr<MacGLContext> m_uploadContext;
+
+  mutable std::mutex m_contextAccess;
+
+  bool m_isInitialized = false;
+  size_t m_initializationCounter = 0;
+  std::condition_variable m_initializationCondition;
+  std::mutex m_initializationMutex;
+
+  bool m_viewSet = false;
+  std::condition_variable m_viewSetCondition;
+  std::mutex m_viewSetMutex;
+};
+
+drape_ptr<dp::GraphicsContextFactory> CreateContextFactory(GLFWwindow *window, dp::ApiVersion api, m2::PointU size) 
+{
+  if (api == dp::ApiVersion::Metal) 
+  {
+    CAMetalLayer *layer = [CAMetalLayer layer];
+    layer.device = MTLCreateSystemDefaultDevice();
+    layer.opaque = YES;
+    layer.displaySyncEnabled = YES;
+
+    NSWindow *nswindow = glfwGetCocoaWindow(window);
+    NSScreen *screen = [NSScreen mainScreen];
+    CGFloat factor = [screen backingScaleFactor];
+    layer.contentsScale = factor;
+    nswindow.contentView.layer = layer;
+    nswindow.contentView.wantsLayer = YES;
+
+    return make_unique_dp<MetalContextFactory>(layer, size);
+  }
+
+  if (api == dp::ApiVersion::Vulkan) 
+  {
+    CAMetalLayer *layer = [CAMetalLayer layer];
+    layer.device = MTLCreateSystemDefaultDevice();
+    layer.opaque = YES;
+    layer.displaySyncEnabled = YES;
+
+    NSWindow *nswindow = glfwGetCocoaWindow(window);
+    NSScreen *screen = [NSScreen mainScreen];
+    CGFloat factor = [screen backingScaleFactor];
+    layer.contentsScale = factor;
+    nswindow.contentView.layer = layer;
+    nswindow.contentView.wantsLayer = YES;
+
+    auto contextFactory = make_unique_dp<MacOSVulkanContextFactory>();
+    contextFactory->SetSurface(layer);
+    return contextFactory;
+  }
+
+  if (api == dp::ApiVersion::OpenGLES3) 
+  {
+    NSWindow *nswindow = glfwGetCocoaWindow(window);
+    [nswindow.contentView setWantsBestResolutionOpenGLSurface:YES];
+    return make_unique_dp<MacGLContextFactory>();
+  }
+
+  ASSERT(false, ("API is not available yet"));
+  return nullptr;
+}
+
+void OnCreateDrapeEngine(GLFWwindow *window, dp::ApiVersion api, 
+                         ref_ptr<dp::GraphicsContextFactory> contextFactory)
+{
+  if (api == dp::ApiVersion::OpenGLES3) 
+  {
+    NSWindow *nswindow = glfwGetCocoaWindow(window);
+    ref_ptr<MacGLContextFactory> macosContextFactory = contextFactory;
+    macosContextFactory->SetView(nswindow.contentView);
+  }
+}
+
+void PrepareDestroyContextFactory(ref_ptr<dp::GraphicsContextFactory> contextFactory) 
+{
+  auto const api = contextFactory->GetDrawContext()->GetApiVersion();
+  if (api == dp::ApiVersion::Metal || api == dp::ApiVersion::OpenGLES3) 
+  {
+    // Do nothing
+  }
+  else if (api == dp::ApiVersion::Vulkan) 
+  {
+    ref_ptr<MacOSVulkanContextFactory> macosContextFactory = contextFactory;
+    macosContextFactory->ResetSurface();
+  }
+  else
+  {
+    ASSERT(false, ("API is not available yet"));
+  }
+}
+
+void UpdateContentScale(GLFWwindow *window, float scale) 
+{
+  NSWindow *nswindow = glfwGetCocoaWindow(window);
+  if (nswindow.contentView.layer)
+    nswindow.contentView.layer.contentsScale = scale;
+}
+
+void UpdateSize(ref_ptr<dp::GraphicsContextFactory> contextFactory, int w, int h) 
+{
+  if (!contextFactory || !contextFactory->GetDrawContext())
+    return;
+
+  auto const api = contextFactory->GetDrawContext()->GetApiVersion();
+  if (api == dp::ApiVersion::OpenGLES3) 
+  {
+    ref_ptr<MacGLContextFactory> macosContextFactory = contextFactory;
+    macosContextFactory->UpdateSize(w, h);
+  }
+}

dev_sandbox/main_linux.cpp

@@ -0,0 +1,411 @@
+#include "std/target_os.hpp"
+#if !defined(OMIM_OS_LINUX)
+#error Unsupported OS
+#endif
+
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
+#define GLFW_EXPOSE_NATIVE_X11
+#include <GLFW/glfw3native.h>
+
+#include <dlfcn.h>
+#include <X11/X.h>
+
+#include <vulkan_wrapper.h>
+#include <vulkan/vulkan_xlib.h>
+// Workaround for TestFunction::Always compilation issue:
+// /usr/include/X11/X.h:441:33: note: expanded from macro 'Always'
+#undef Always
+// Workaround for storage::Status compilation issue:
+// /usr/include/X11/Xlib.h:83:16: note: expanded from macro 'Status'
+#undef Status
+
+#include "drape/vulkan/vulkan_context_factory.hpp"
+
+#include "drape/gl_functions.hpp"
+#include "drape/gl_includes.hpp"
+#include "drape/oglcontext.hpp"
+
+#include <array>
+#include <atomic>
+#include <memory>
+
+class LinuxVulkanContextFactory : public dp::vulkan::VulkanContextFactory
+{
+public:
+  LinuxVulkanContextFactory() : dp::vulkan::VulkanContextFactory(1, 33, false) {}
+
+  void SetSurface(Display * display, Window window)
+  {
+    VkXlibSurfaceCreateInfoKHR const createInfo = {
+        .sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
+        .pNext = nullptr,
+        .flags = 0,
+        .dpy = display,
+        .window = window,
+    };
+
+    VkResult statusCode;
+    CHECK(vkCreateXlibSurfaceKHR, ());
+    statusCode = vkCreateXlibSurfaceKHR(m_vulkanInstance, &createInfo, nullptr, &m_surface);
+    if (statusCode != VK_SUCCESS)
+    {
+      LOG_ERROR_VK_CALL(vkCreateXlibSurfaceKHR, statusCode);
+      return;
+    }
+
+    uint32_t const renderingQueueIndex = m_drawContext->GetRenderingQueueFamilyIndex();
+    VkBool32 supportsPresent;
+    statusCode = vkGetPhysicalDeviceSurfaceSupportKHR(m_gpu, renderingQueueIndex, m_surface, &supportsPresent);
+    if (statusCode != VK_SUCCESS)
+    {
+      LOG_ERROR_VK_CALL(vkGetPhysicalDeviceSurfaceSupportKHR, statusCode);
+      return;
+    }
+    CHECK_EQUAL(supportsPresent, VK_TRUE, ());
+
+    CHECK(QuerySurfaceSize(), ());
+
+    if (m_drawContext)
+      m_drawContext->SetSurface(m_surface, m_surfaceFormat, m_surfaceCapabilities);
+  }
+
+  void ResetSurface()
+  {
+    if (m_drawContext)
+      m_drawContext->ResetSurface(false);
+
+    vkDestroySurfaceKHR(m_vulkanInstance, m_surface, nullptr);
+  }
+};
+
+// Based on: https://github.com/glfw/glfw/blob/master/src/glx_context.c
+#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
+#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
+#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
+#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
+#define GLX_PBUFFER_HEIGHT 0x8040
+#define GLX_PBUFFER_WIDTH 0x8041
+#define GLX_DOUBLEBUFFER 5
+#define GLX_DRAWABLE_TYPE 0x8010
+#define GLX_RENDER_TYPE 0x8011
+#define GLX_WINDOW_BIT 0x00000001
+#define GLX_PBUFFER_BIT 0x00000004
+#define GLX_RGBA_BIT 0x00000001
+#define GLX_RED_SIZE 8
+#define GLX_GREEN_SIZE 9
+#define GLX_BLUE_SIZE 10
+#define GLX_ALPHA_SIZE 11
+#define GLX_DEPTH_SIZE 12
+#define GLX_STENCIL_SIZE 13
+
+typedef XID GLXDrawable;
+typedef struct __GLXcontext * GLXContext;
+typedef XID GLXPbuffer;
+typedef struct __GLXFBConfig * GLXFBConfig;
+typedef void (*__GLXextproc)(void);
+
+typedef __GLXextproc (*PFNGLXGETPROCADDRESSPROC)(const GLubyte * procName);
+
+typedef int (*PFNXFREE)(void *);
+typedef GLXFBConfig * (*PFNGLXCHOOSEFBCONFIGPROC)(Display *, int, const int *, int *);
+typedef GLXContext (*PFNGLXCREATECONTEXTATTRIBSARB)(Display *, GLXFBConfig, GLXContext, Bool, const int *);
+typedef void (*PFNGLXDESTROYCONTEXT)(Display *, GLXContext);
+typedef GLXPbuffer (*PFNGLXCREATEPBUFFERPROC)(Display *, GLXFBConfig, const int *);
+typedef void (*PFNGLXDESTROYPBUFFER)(Display *, GLXPbuffer);
+typedef Bool (*PFNGLXMAKECURRENTPROC)(Display *, GLXDrawable, GLXContext);
+typedef void (*PFNGLXSWAPBUFFERSPROC)(Display *, GLXDrawable);
+
+struct GLXFunctions
+{
+  GLXFunctions()
+  {
+    std::array<char const *, 3> libs = {
+        "libGLX.so.0",
+        "libGL.so.1",
+        "libGL.so",
+    };
+
+    for (char const * lib : libs)
+    {
+      m_module = dlopen(lib, RTLD_LAZY | RTLD_LOCAL);
+      if (m_module)
+      {
+        break;
+      }
+    }
+
+    CHECK(m_module != nullptr, ("Failed to initialize GLX"));
+
+    XFree = loadFunction<PFNXFREE>("XFree");
+
+    glXGetProcAddress = loadFunction<PFNGLXGETPROCADDRESSPROC>("glXGetProcAddress");
+    glXGetProcAddressARB = loadFunction<PFNGLXGETPROCADDRESSPROC>("glXGetProcAddressARB");
+
+    glXChooseFBConfig = loadGlxFunction<PFNGLXCHOOSEFBCONFIGPROC>("glXChooseFBConfig");
+    glXCreateContextAttribsARB = loadGlxFunction<PFNGLXCREATECONTEXTATTRIBSARB>("glXCreateContextAttribsARB");
+
+    glXDestroyContext = loadGlxFunction<PFNGLXDESTROYCONTEXT>("glXDestroyContext");
+    glXCreatePbuffer = loadGlxFunction<PFNGLXCREATEPBUFFERPROC>("glXCreatePbuffer");
+    glXDestroyPbuffer = loadGlxFunction<PFNGLXDESTROYPBUFFER>("glXDestroyPbuffer");
+    glXMakeCurrent = loadGlxFunction<PFNGLXMAKECURRENTPROC>("glXMakeCurrent");
+    glXSwapBuffers = loadGlxFunction<PFNGLXSWAPBUFFERSPROC>("glXSwapBuffers");
+  }
+
+  ~GLXFunctions()
+  {
+    if (m_module)
+    {
+      dlclose(m_module);
+    }
+  }
+
+  PFNXFREE XFree = nullptr;
+
+  PFNGLXGETPROCADDRESSPROC glXGetProcAddress = nullptr;
+  PFNGLXGETPROCADDRESSPROC glXGetProcAddressARB = nullptr;
+
+  PFNGLXCHOOSEFBCONFIGPROC glXChooseFBConfig = nullptr;
+  PFNGLXCREATECONTEXTATTRIBSARB glXCreateContextAttribsARB = nullptr;
+  PFNGLXDESTROYCONTEXT glXDestroyContext = nullptr;
+  PFNGLXCREATEPBUFFERPROC glXCreatePbuffer = nullptr;
+  PFNGLXDESTROYPBUFFER glXDestroyPbuffer = nullptr;
+  PFNGLXMAKECURRENTPROC glXMakeCurrent = nullptr;
+  PFNGLXSWAPBUFFERSPROC glXSwapBuffers = nullptr;
+
+private:
+  template <typename T>
+  T loadFunction(char const * func)
+  {
+    auto f = reinterpret_cast<T>(dlsym(m_module, func));
+    ASSERT(f, ("Failed to initialize GLX:", func, "is not found"));
+    return f;
+  }
+
+  template <typename T>
+  T loadGlxFunction(char const * func)
+  {
+    if (auto f = reinterpret_cast<T>(glXGetProcAddress(reinterpret_cast<GLubyte const *>(func))))
+      return f;
+
+    if (auto f = reinterpret_cast<T>(glXGetProcAddressARB(reinterpret_cast<GLubyte const *>(func))))
+      return f;
+
+    return loadFunction<T>(func);
+  }
+
+  void * m_module = nullptr;
+};
+
+class LinuxGLContext : public dp::OGLContext
+{
+public:
+  LinuxGLContext(GLXFunctions const & glx, Display * display, Window window, LinuxGLContext * contextToShareWith,
+                 bool usePixelBuffer)
+    : m_glx(glx), m_display(display), m_window(window)
+  {
+    int visualAttribs[] = {
+      GLX_DOUBLEBUFFER, True,
+      GLX_RENDER_TYPE, GLX_RGBA_BIT,
+      GLX_DRAWABLE_TYPE, (usePixelBuffer ? GLX_PBUFFER_BIT : GLX_WINDOW_BIT),
+      GLX_RED_SIZE, 8,
+      GLX_GREEN_SIZE, 8,
+      GLX_BLUE_SIZE, 8,
+      GLX_ALPHA_SIZE, 8,
+      GLX_DEPTH_SIZE, 24,
+      GLX_STENCIL_SIZE, 8,
+      None
+    };
+    int contextAttribs[] = {
+      GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
+      GLX_CONTEXT_MAJOR_VERSION_ARB, 4, 
+      GLX_CONTEXT_MINOR_VERSION_ARB, 1,
+      None};
+    int fbcount = 0;
+    if (GLXFBConfig * config = m_glx.glXChooseFBConfig(display, DefaultScreen(display), visualAttribs, &fbcount))
+    {
+      m_context =
+          m_glx.glXCreateContextAttribsARB(display, config[0], contextToShareWith ? contextToShareWith->m_context : 0, True, contextAttribs);
+      CHECK(m_context != nullptr, ("Failed to create GLX context"));
+
+      if (usePixelBuffer)
+      {
+        int pbufferAttribs[] = {GLX_PBUFFER_WIDTH, 1, GLX_PBUFFER_HEIGHT, 1, None};
+
+        m_pixelBufferHandle = m_glx.glXCreatePbuffer(display, config[0], pbufferAttribs);
+        CHECK(m_pixelBufferHandle != 0, ("Failed to create GLX pbuffer"));
+      }
+
+      m_glx.XFree(config);
+    }
+  }
+
+  ~LinuxGLContext() override
+  {
+    if (m_pixelBufferHandle)
+    {
+      m_glx.glXDestroyPbuffer(m_display, m_pixelBufferHandle);
+      m_pixelBufferHandle = 0;
+    }
+    if (m_context)
+    {
+      m_glx.glXDestroyContext(m_display, m_context);
+      m_context = nullptr;
+    }
+  }
+
+  void Present() override
+  {
+    if (!m_pixelBufferHandle)
+      m_glx.glXSwapBuffers(m_display, m_window);
+  }
+
+  void MakeCurrent() override
+  {
+    if (!m_glx.glXMakeCurrent(m_display, m_pixelBufferHandle ? m_pixelBufferHandle : m_window, m_context))
+      LOG(LERROR, ("MakeCurrent(): glXMakeCurrent failed"));
+  }
+
+  void DoneCurrent() override
+  {
+    if (!m_glx.glXMakeCurrent(m_display, None, nullptr))
+      LOG(LERROR, ("DoneCurrent(): glXMakeCurrent failed"));
+  }
+
+  void SetFramebuffer(ref_ptr<dp::BaseFramebuffer> framebuffer) override
+  {
+    if (framebuffer)
+      framebuffer->Bind();
+    else
+      GLFunctions::glBindFramebuffer(0);
+  }
+
+private:
+  GLXFunctions const & m_glx;
+
+  Display * m_display = nullptr;
+  Window m_window = 0;
+  GLXDrawable m_pixelBufferHandle = 0;
+  GLXContext m_context = nullptr;
+};
+
+class LinuxContextFactory : public dp::GraphicsContextFactory
+{
+public:
+  LinuxContextFactory(Display * display, Window window) : m_display(display), m_window(window) {}
+
+  dp::GraphicsContext * GetDrawContext() override
+  {
+    std::lock_guard<std::mutex> lock(m_contextAccess);
+    if (m_drawContext == nullptr)
+      m_drawContext = std::make_unique<LinuxGLContext>(m_glx, m_display, m_window, m_uploadContext.get(), false);
+    return m_drawContext.get();
+  }
+
+  dp::GraphicsContext * GetResourcesUploadContext() override
+  {
+    std::lock_guard<std::mutex> lock(m_contextAccess);
+    if (m_uploadContext == nullptr)
+      m_uploadContext = std::make_unique<LinuxGLContext>(m_glx, m_display, 0, m_drawContext.get(), true);
+    return m_uploadContext.get();
+  }
+
+  void WaitForInitialization(dp::GraphicsContext *) override
+  {
+    std::unique_lock<std::mutex> lock(m_initializationMutex);
+    if (m_isInitialized)
+      return;
+
+    m_initializationCounter++;
+    if (m_initializationCounter >= kGLThreadsCount)
+    {
+      m_isInitialized = true;
+      m_initializationCondition.notify_all();
+    }
+    else
+    {
+      m_initializationCondition.wait(lock, [this] { return m_isInitialized; });
+    }
+  }
+
+  bool IsDrawContextCreated() const override
+  {
+    std::lock_guard<std::mutex> lock(m_contextAccess);
+    return m_drawContext != nullptr;
+  }
+
+  bool IsUploadContextCreated() const override
+  {
+    std::lock_guard<std::mutex> lock(m_contextAccess);
+    return m_uploadContext != nullptr;
+  }
+
+private:
+  static size_t constexpr kGLThreadsCount = 2;
+
+  GLXFunctions m_glx;
+
+  Display * m_display = nullptr;
+  Window m_window = 0;
+
+  std::unique_ptr<LinuxGLContext> m_drawContext;
+  std::unique_ptr<LinuxGLContext> m_uploadContext;
+
+  mutable std::mutex m_contextAccess;
+
+  bool m_isInitialized = false;
+  size_t m_initializationCounter = 0;
+  std::condition_variable m_initializationCondition;
+  std::mutex m_initializationMutex;
+};
+
+drape_ptr<dp::GraphicsContextFactory> CreateContextFactory(GLFWwindow * window, dp::ApiVersion api, m2::PointU size)
+{
+  if (api == dp::ApiVersion::Vulkan)
+  {
+    auto contextFactory = make_unique_dp<LinuxVulkanContextFactory>();
+    contextFactory->SetSurface(glfwGetX11Display(), glfwGetX11Window(window));
+    return contextFactory;
+  }
+
+  if (api == dp::ApiVersion::OpenGLES3)
+  {
+    return make_unique_dp<LinuxContextFactory>(glfwGetX11Display(), glfwGetX11Window(window));
+  }
+
+  ASSERT(false, ("API is not available yet"));
+  return nullptr;
+}
+
+void OnCreateDrapeEngine(GLFWwindow * window, dp::ApiVersion api, ref_ptr<dp::GraphicsContextFactory> contextFactory)
+{
+  // Do nothing
+}
+
+void PrepareDestroyContextFactory(ref_ptr<dp::GraphicsContextFactory> contextFactory)
+{
+  auto const api = contextFactory->GetDrawContext()->GetApiVersion();
+  if (api == dp::ApiVersion::OpenGLES3)
+  {
+    // Do nothing
+  }
+  else if (api == dp::ApiVersion::Vulkan)
+  {
+    ref_ptr<LinuxVulkanContextFactory> linuxContextFactory = contextFactory;
+    linuxContextFactory->ResetSurface();
+  }
+  else
+  {
+    ASSERT(false, ("API is not available yet"));
+  }
+}
+
+void UpdateContentScale(GLFWwindow * window, float scale)
+{
+  // Do nothing
+}
+
+void UpdateSize(ref_ptr<dp::GraphicsContextFactory> contextFactory, int w, int h)
+{
+  // Do nothing
+}

docs/INSTALL.md

@@ -115,6 +115,10 @@ sudo apt update && sudo apt install -y \
     libqt6positioning6-plugins \
     libqt6positioning6 \
     libsqlite3-dev \
+    libxrandr-dev \
+    libxinerama-dev \
+    libxcursor-dev \
+    libxi-dev \
     zlib1g-dev
 ```
 

docs/STRUCTURE.md

@@ -84,6 +84,7 @@ Automatically [generated](TRANSLATIONS.md#technical-details):
 - `cmake/` - CMake helper files.
 - `coding/` - I/O classes and data processing.
 - `descriptions/` -
+- `dev_sandbox/` - developer tool for debugging rendering.
 - `drape_frontend/` - scene and resource manager for the Drape library.
 - `drape/` - the new graphics library core.
 - `editor/` - built-in OSM data editor.

indexer/edit_journal.hpp

@@ -6,6 +6,7 @@
 
 #include <functional>
 #include <string>
+#include <variant>
 #include <vector>
 
 namespace osm

shaders/GL/imgui.fsh.glsl

@@ -0,0 +1,10 @@
+varying vec2 v_texCoords;
+varying vec4 v_color;
+
+uniform sampler2D u_colorTex;
+
+void main()
+{
+  LOW_P vec4 color = texture2D(u_colorTex, v_texCoords);
+  gl_FragColor = color * v_color;
+}

shaders/GL/imgui.vsh.glsl

@@ -0,0 +1,19 @@
+attribute vec2 a_position;
+attribute vec2 a_texCoords;
+attribute vec4 a_color;
+
+varying vec2 v_texCoords;
+varying vec4 v_color;
+
+uniform mat4 u_projection;
+
+void main()
+{
+  v_texCoords = a_texCoords;
+  v_color = a_color;
+  gl_Position = vec4(a_position, 0, 1) * u_projection;
+#ifdef VULKAN
+  gl_Position.y = -gl_Position.y;
+  gl_Position.z = (gl_Position.z  + gl_Position.w) * 0.5;
+#endif
+}

shaders/GL/shader_index.txt

@@ -53,3 +53,4 @@ TrafficCircle traffic_circle.vsh.glsl traffic_circle.fsh.glsl
 SmaaEdges smaa_edges.vsh.glsl smaa_edges.fsh.glsl
 SmaaBlendingWeight smaa_blending_weight.vsh.glsl smaa_blending_weight.fsh.glsl
 SmaaFinal smaa_final.vsh.glsl smaa_final.fsh.glsl
+ImGui imgui.vsh.glsl imgui.fsh.glsl

shaders/Metal/imgui.metal

@@ -0,0 +1,39 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+using namespace metal;
+
+typedef struct
+{
+  float2 a_position [[attribute(0)]];
+  float2 a_texCoords [[attribute(1)]];
+  float4 a_color [[attribute(2)]];
+} Vertex_T;
+
+typedef struct
+{
+  float4 position [[position]];
+  float2 texCoords;
+  float4 color;
+} Fragment_T;
+
+typedef struct
+{
+  float4x4 u_projection;
+} Uniforms_T;
+
+vertex Fragment_T vsImGui(const Vertex_T in [[stage_in]],
+                          constant Uniforms_T & uniforms [[buffer(1)]])
+{
+  Fragment_T out;
+  out.position = float4(in.a_position, 0.0, 1.0) * uniforms.u_projection;
+  out.texCoords = in.a_texCoords;
+  out.color = in.a_color;
+  return out;
+}
+
+fragment float4 fsImGui(const Fragment_T in [[stage_in]],
+                        texture2d<float> u_colorTex [[texture(0)]],
+                        sampler u_colorTexSampler [[sampler(0)]])
+{
+  return in.color * u_colorTex.sample(u_colorTexSampler, in.texCoords);
+}

shaders/gl_program_params.cpp

@@ -230,4 +230,14 @@ void GLProgramParamsSetter::Apply(ref_ptr<dp::GraphicsContext> context,
 
   Parameter::CheckApply(guard, "u_framebufferMetrics", params.m_framebufferMetrics);
 }
+
+void GLProgramParamsSetter::Apply(ref_ptr<dp::GraphicsContext> context,
+                                  ref_ptr<dp::GpuProgram> program, 
+                                  ImGuiProgramParams const & params)
+{
+  UNUSED_VALUE(context);
+  UniformsGuard guard(program, params);
+
+  Parameter::CheckApply(guard, "u_projection", params.m_projection);
+}
 }  // namespace gpu

shaders/gl_program_params.hpp

@@ -29,5 +29,7 @@ public:
              ref_ptr<dp::GpuProgram> program, ScreenQuadProgramParams const & params) override;
   void Apply(ref_ptr<dp::GraphicsContext> context,
              ref_ptr<dp::GpuProgram> program, SMAAProgramParams const & params) override;
+  void Apply(ref_ptr<dp::GraphicsContext> context,
+             ref_ptr<dp::GpuProgram> program, ImGuiProgramParams const & params) override;
 };
 }  // namespace gpu

shaders/metal_program_params.hpp

@@ -31,6 +31,8 @@ public:
              ScreenQuadProgramParams const & params) override;
   void Apply(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::GpuProgram> program,
              SMAAProgramParams const & params) override;
+  void Apply(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::GpuProgram> program,
+             ImGuiProgramParams const & params) override;
 };
 }  // namespace metal
 }  // namespace gpu

shaders/metal_program_params.mm

@@ -101,5 +101,12 @@ void MetalProgramParamsSetter::Apply(ref_ptr<dp::GraphicsContext> context,
 {
   ApplyBytes(context, program, params);
 }
+
+void MetalProgramParamsSetter::Apply(ref_ptr<dp::GraphicsContext> context, 
+                                     ref_ptr<dp::GpuProgram> program,
+                                     ImGuiProgramParams const & params)
+{
+  ApplyBytes(context, program, params);
+}
 }  // namespace metal
 }  // namespace gpu

shaders/metal_program_pool.mm

@@ -102,6 +102,7 @@ std::array<ProgramInfo, static_cast<size_t>(Program::ProgramsCount)> const kMeta
   ProgramInfo("vsSmaaEdges", "fsSmaaEdges", {{0, 1}}),                             // SmaaEdges
   ProgramInfo("vsSmaaBlendingWeight", "fsSmaaBlendingWeight", {{0, 1}}),           // SmaaBlendingWeight
   ProgramInfo("vsSmaaFinal", "fsSmaaFinal", {{0, 1}}),                             // SmaaFinal
+  ProgramInfo("vsImGui", "fsImGui", {{0, 2}}),                                     // ImGui
 }};
 
 MTLVertexFormat GetFormatByDataType(MTLDataType dataType)

shaders/program_params.cpp

@@ -18,6 +18,7 @@ void ProgramParams::Init()
   DebugRectProgramParams::BindPrograms(m_boundParams);
   ScreenQuadProgramParams::BindPrograms(m_boundParams);
   SMAAProgramParams::BindPrograms(m_boundParams);
+  ImGuiProgramParams::BindPrograms(m_boundParams);
 }
 
 // static

shaders/program_params.hpp

@@ -222,6 +222,14 @@ struct ALIGNMENT SMAAProgramParams
     Program::SmaaFinal)
 };
 
+struct ALIGNMENT ImGuiProgramParams
+{
+  glsl::mat4 m_projection;
+
+  BIND_PROGRAMS(ImGuiProgramParams,
+    Program::ImGui)
+};
+
 #undef ALIGNMENT
 
 class ProgramParamsSetter
@@ -248,5 +256,7 @@ public:
                      ref_ptr<dp::GpuProgram> program, ScreenQuadProgramParams const & params) = 0;
   virtual void Apply(ref_ptr<dp::GraphicsContext> context,
                      ref_ptr<dp::GpuProgram> program, SMAAProgramParams const & params) = 0;
+  virtual void Apply(ref_ptr<dp::GraphicsContext> context,
+                     ref_ptr<dp::GpuProgram> program, ImGuiProgramParams const & params) = 0;
 };
 }  // namespace gpu

shaders/programs.hpp

@@ -65,6 +65,7 @@ enum class Program
   SmaaEdges,
   SmaaBlendingWeight,
   SmaaFinal,
+  ImGui,
 
   ProgramsCount
 };
@@ -128,6 +129,7 @@ inline std::string DebugPrint(Program p)
   case Program::SmaaEdges: return "SmaaEdges";
   case Program::SmaaBlendingWeight: return "SmaaBlendingWeight";
   case Program::SmaaFinal: return "SmaaFinal";
+  case Program::ImGui: return "ImGui";
 
   case Program::ProgramsCount:
     CHECK(false, ("Try to output ProgramsCount"));

shaders/vulkan_program_params.cpp

@@ -229,5 +229,12 @@ void VulkanProgramParamsSetter::Apply(ref_ptr<dp::GraphicsContext> context,
 {
   ApplyImpl(context, program, params);
 }
+
+void VulkanProgramParamsSetter::Apply(ref_ptr<dp::GraphicsContext> context,
+                                      ref_ptr<dp::GpuProgram> program, 
+                                      ImGuiProgramParams const & params)
+{
+  ApplyImpl(context, program, params);
+}
 }  // namespace vulkan
 }  // namespace gpu

shaders/vulkan_program_params.hpp

@@ -55,6 +55,8 @@ public:
              ScreenQuadProgramParams const & params) override;
   void Apply(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::GpuProgram> program,
              SMAAProgramParams const & params) override;
+  void Apply(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::GpuProgram> program,
+             ImGuiProgramParams const & params) override;
 
 private:
   template<typename T>