Сверка документации с кодом: исправлены расхождения

Сплошная проверка документов против дерева. Код не менялся.

docs/rust_vs_cpp.md — числа, снятые с чужого каталога сборки:
- «775 МБ исходников зависимостей» и «10 пакетов в графе C++» получены
  на build/, сконфигурированном из другого дерева (его _deps содержит
  262 МБ nlohmann_json, который проект не объявляет). На деле девять
  объявленных репозиториев дают ~400 МБ исходников;
- пакетов в графе Rust 82, а не 76 (cargo tree по текущему Cargo.lock);
- итог по строкам 2976/494, а не 2962/492: строка «меш» устарела на 17
  строк игнорируемого диагностического теста, тесты в модулях — 176;
- «перевес почти весь в Vulkan-слое» — на деле 346 из 542 (64 %), из них
  305 на Context и Swapchain; остальное приходится на меш, редактор и
  приложение;
- «ни один замер не даёт разницы в порядок величины» неверно:
  инкрементальная release — 52.3 против 4.4 с, это 11.9x;
- граней с пятью и более вершинами в plane.obj 119, а не 121;
- из Catch2 перенесены все три случая, и добавлено ещё два, а не
  «три перенесены дословно»;
- деструктор Renderer::Impl — 22 строки, а не тридцать;
- путевых зависимостей у порта две: assets/meshes с откатом на текущий
  каталог и pipeline_cache.bin рядом с бинарём;
- граф целей CMake ацикличен, цикл существует на уровне исходников —
  именно поэтому CMake и молчит.

rust/README.md:
- объявленный rust-version = "1.82" недостижим: залоченные egui,
  egui-winit и epaint 0.36.1 требуют 1.95;
- перечни зависимостей крейтов были неполны, приведены целиком;
- build.rs читает ../../../shaders, а не ../../shaders;
- тесты не «чистая математика»: тесты загрузчика читают файлы из
  assets/meshes и требуют клон репозитория;
- assets/ порту никто не копирует, он находит корневую копию сам;
- те же поправки про цикл в CMake и про момент ожидания простоя.

README.md:
- панель называется Mesh, а не «Mesh load»;
- пресета clang-cl не существует, компилятор пресеты не фиксируют;
- версии Vulkan SDK и компиляторов сборкой не проверяются;
- Buffer и Image перечислены среди рабочих модулей vk/, хотя ими не
  пользуется никто.

docs/theory/solver_2x_sdf/README.md:
- предлагался несуществующий переключатель cfg.collision="bgk" и реестр
  операторов get; тот же файл двумя разделами ниже говорит, что оператор
  зафиксирован.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.gitignore

@@ -40,6 +40,13 @@ docs/theory/solver_2x_sdf/out/
 # ноутбук kbc_lbm.ipynb их встраивает, и без них он нечитаем на свежем клоне
 # (перегенерация требует GPU-сервера). См. заметку о них в README ветки research.
 
+# ---------------------------------------------------------------------------
+#  Rust (rust/ — порт редактора)
+# ---------------------------------------------------------------------------
+# Каталог сборки cargo: объектники, зависимости, инкрементальный кэш.
+target/
+# Cargo.lock для приложения коммитят (воспроизводимость сборки) — он НЕ игнорируется.
+
 # ---------------------------------------------------------------------------
 #  Редакторы и ОС
 # ---------------------------------------------------------------------------
@@ -53,3 +60,6 @@ docs/theory/solver_2x_sdf/out/
 .DS_Store
 Thumbs.db
 desktop.ini
+
+# Общие заметки Claude Code: один файл на все ветки, вне версионирования
+/CLAUDE.md

CLAUDE.md

@@ -1,202 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-**SimVulcan** is a minimal **Vulkan 1.3 / C++20** 3D model editor. It renders a
-3D editor space — three reference grid planes (XY, XZ, YZ) through the origin plus
-coloured X/Y/Z axes — viewed through an orbit camera, and loads/displays `.obj`
-models with selectable display modes (solid, wireframe, solid + wireframe).
-
-The C++ side runs no simulation: it is a focused rendering skeleton with an ImGui
-interface (a Viewport control panel and a Mesh load panel). The repository *also*
-carries an unrelated Python research prototype under `docs/theory/` — see
-[Research prototype](#research-prototype-docstheory) below; it is not part of the
-CMake build.
-
-## Build
-
-Prerequisites: **Vulkan SDK 1.3.290+** (provides `glslangValidator` for offline
-shader compilation), **CMake 3.26+**, **Ninja**, a C++20 compiler (MSVC 19.36+,
-gcc 11+, clang 14+). On macOS, Vulkan is via MoltenVK (Apple Silicon only).
-
-```sh
-cmake --preset windows-msvc-release
-cmake --build --preset windows-msvc-release
-```
-
-Presets: `windows-msvc-debug`, `windows-msvc-release`, `linux-gcc-release`,
-`linux-clang-release`, `macos-arm64-release` (all Ninja, one dir per preset under
-`build/<presetName>/`). The first configure fetches dependencies via FetchContent
-(GLFW, GLM, volk, vk-bootstrap, VulkanMemoryAllocator, Dear ImGui, spdlog,
-tinyobjloader, Catch2) and needs network access. `VK_NO_PROTOTYPES` is set
-project-wide; Vulkan entry points load through **volk**.
-
-Warnings come from `simv_set_warnings` (`/W4 /permissive-`, or
-`-Wall -Wextra -Wpedantic -Wshadow -Wold-style-cast …`); they are **not** errors.
-`cmake/Sanitizers.cmake` defines `simv_enable_sanitizers` (Debug-only ASan/UBSan)
-but no target currently calls it — wire it in manually when chasing memory bugs.
-
-## Running
-
-The executable resolves SPIR-V relative to the working directory (`FindSpvPath`
-probes `spirv/<rel>` and `current_path()/spirv/<rel>`). The `SimVulcan` POST_BUILD
-step copies the compiled `spirv/` tree and `assets/` next to the executable, so
-**run from the executable's own directory** (`build/<preset>/src/app/`). `main.cpp`
-also probes several `../` ancestors for `assets/meshes`. Meshes load at runtime
-through the ImGui Mesh panel.
-
-Running writes two files into the CWD: `pipeline_cache.bin` (serialised
-`VkPipelineCache`, reloaded on the next start) and ImGui's `imgui.ini`. Both are
-disposable — delete them if pipeline creation or the panel layout misbehaves.
-
-`ContextOptions::enableValidation` / `enableDebugUtils` default to **true** in
-every build config, so the Khronos validation layer is requested even in Release;
-messages (error + warning severity) go through spdlog.
-
-`run.bat` at the repo root is **stale**: it launches
-`build/vs2022/src/app/Release/SimVulcan.exe`, a path the Ninja presets never
-produce. Do not point users at it without fixing the path first.
-
-## Tests
-
-Catch2 unit tests, pure CPU/math (mesh bounds + welding). No GPU required.
-
-```sh
-cmake --build --preset windows-msvc-debug --target simv_tests
-ctest --preset windows-msvc-debug
-```
-
-`windows-msvc-debug` is the only preset with a `testPreset` — for the other
-configs, invoke `ctest` in `build/<preset>/` directly.
-
-Single test / subset — either through CTest (each `TEST_CASE` is registered
-individually by `catch_discover_tests`):
-
-```sh
-ctest --preset windows-msvc-debug -R "WeldVertices" -V
-```
-
-or by running the binary with a Catch2 name or tag filter:
-
-```sh
-./build/windows-msvc-debug/tests/simv_tests.exe "[decimator]"
-./build/windows-msvc-debug/tests/simv_tests.exe --list-tests
-```
-
-## Architecture
-
-### Library / target map
-
-```
-SimVulcan (exe) → simv_core, simv_vk, simv_mesh, simv_editor
-simv_core   → simv_vk            (App owns Window + vk::Renderer; no Vulkan calls)
-simv_editor → simv_core, simv_mesh   (Camera, input, ImGui panels; no Vulkan)
-simv_mesh   → simv_core              (CPU mesh only; no Vulkan)
-simv_vk     → third-party (volk, vk-bootstrap, VMA, GLFW, GLM, spdlog, imgui)
-simv_shaders → glslangValidator (GLSL → SPIR-V)
-```
-
-Namespaces follow directories: `simv::core`, `simv::vk`, `simv::mesh`,
-`simv::editor`. Each library exports `src/` as its include root, so includes are
-written module-qualified (`#include "mesh/Mesh.h"`, `#include "vk/Renderer.h"`).
-
-### Frame loop
-
-`main.cpp` creates `core::App`, which owns the `core::Window` and a
-`vk::Renderer`, then runs the loop. Each frame `Renderer::DrawFrame` calls the UI
-callback (between ImGui NewFrame/Render), then records the scene: grid + mesh into
-one dynamic-rendering pass with a depth attachment, followed by ImGui, then
-presents (2 frames in flight, sync2 submits).
-
-`main.cpp` wires the editor via the UI callback: it draws the panels, applies
-mouse input to the `editor::Camera`, and pushes the resulting state into the
-renderer (`SetViewProj`, `SetRenderMode`, `SetGridVisible`). Mesh loads go through
-`MeshLoadPanel`'s callback → `Renderer::SetMeshCpu`.
-
-### Mesh load path
-
-`MeshLoadPanel` lists `*.obj` in the mesh directory and kicks off
-`mesh::LoadObjAsync` (worker thread, `std::future`). The future is **drained on
-the main thread** at the top of `MeshLoadPanel::Draw`, so the `OnLoaded` callback
-— and therefore the GPU upload — always runs on the render thread. Loader
-exceptions surface as the panel's status string.
-
-`main.cpp`'s `OnLoaded` welds the mesh (`WeldVertices`, tolerance `1e-4`), logs
-the counts, uploads via `SetMeshCpu`, and reframes the camera to the bbox radius.
-Despite the file name, `mesh/MeshDecimator.h` implements **only** spatial-hash
-vertex welding (collapse near-duplicates, drop degenerate triangles, recompute
-bounds) — there is no LOD/decimation.
-
-### Non-obvious invariants (read before editing)
-
-- **All Vulkan lives in `src/vk/`.** `core/`, `mesh/`, `editor/` and `app/` make no
-  Vulkan API calls. `vk::Renderer`'s public header is deliberately Vulkan-free
-  (pImpl + glm/`RenderMode` only) so `App` can own it without pulling in volk. Keep
-  it that way — do not leak `Vk*` types into the public interfaces of those modules.
-- **Single render pass with depth.** Scene (grid + mesh) and ImGui draw into one
-  `vkCmdBeginRendering` pass that has both a colour and a `D32_SFLOAT` depth
-  attachment. The ImGui backend is initialised with `depthAttachmentFormat` set so
-  its pipeline matches the pass; the depth buffer is recreated with the swapchain.
-- **Wireframe needs `fillModeNonSolid`.** `MeshRenderer` builds a fill pipeline and
-  a `VK_POLYGON_MODE_LINE` pipeline; the line pipeline uses a small depth bias so
-  the overlay sits on top of the fill. The device feature is requested in `Context`.
-  Culling is off (`VK_CULL_MODE_NONE`) — loaded models may have mixed winding.
-- **Camera is fixed on the origin.** `editor::Camera` orbits (yaw/pitch/distance)
-  the world origin; loaded models are recentred there via a translate-only model
-  matrix. Projection uses Vulkan clip space (`GLM_FORCE_DEPTH_ZERO_TO_ONE` + Y flip,
-  isolated to `Camera.cpp`).
-- **Buffers.** `vk::GpuMesh` owns the model's vertex/index buffers (staged upload on
-  the transfer queue). `GridRenderer` builds a static host-visible line buffer once.
-  Both scene renderers use only a push constant — no descriptor sets.
-- **Push-constant layout is a cross-file contract.** `MeshRenderer.cpp`'s anonymous
-  `MeshPC { mat4 mvp; vec4 color; }` must stay byte-identical to the
-  `push_constant` block in `mesh.vert`/`mesh.frag`; `color.a` is a *flag*, not
-  alpha (1 = flat-shaded, 0 = constant colour for wireframe). `GridRenderer` pushes
-  a bare `mat4` (vertex stage only). Change either side and you must change both.
-- **Swapchain recreation rebuilds sync objects.** `RecreateSwapDependent` recreates
-  the per-frame `imageAvailable` semaphores (a failed acquire can leave one
-  signalled) *and* the per-swapchain-image `renderFinished` semaphores (the image
-  count may change), then re-ensures both pipelines. Keep that ordering if you
-  touch resize handling.
-- **Mesh upload stalls the device.** `SetMeshCpu`/`ClearMesh` call `WaitIdle`
-  before touching `GpuMesh` — acceptable because loads are rare; do not copy that
-  pattern into per-frame paths.
-
-### Shaders
-
-GLSL under `shaders/editor/` (`mesh.{vert,frag}`, `grid.{vert,frag}`). `simv_shaders`
-compiles each to `build/<preset>/spirv/editor/<name>.spv` targeting `vulkan1.3`,
-with `shaders/` as the `-I` root (so `#include "common/foo.glsl"` would resolve).
-Adding a shader under that globbed dir is picked up automatically
-(`CONFIGURE_DEPENDS`). `mesh.frag` reconstructs a flat normal from screen-space
-derivatives, so the vertex stream carries only positions (tight `float3`, one
-binding, one attribute).
-
-## Logging
-
-`simv::core::Logger` (spdlog-backed, singleton) with category-based throttling.
-Log via `LogFmt(LogCategory, LogLevel, fmt, args...)`. Categories: `Core`,
-`Vulkan`, `MeshIO`, `UI`, `Test`. Per-category level, throttle interval and
-on/off are settable at runtime (`SetMinLevel` / `SetThrottle` / `SetEnabled`).
-Some low-level Vulkan code still calls `spdlog::` directly.
-
-## Research prototype (`docs/theory/`)
-
-Separate from the C++ application and from the CMake build: a Python **Lattice
-Boltzmann (D2Q9, KBC-N1)** research codebase — cylinder flow with a ×2 nested AMR
-patch and SDF+Bouzidi boundaries. **GPU/CuPy only, no CPU fallback.** Its
-documentation and the running experiment log are in Russian.
-
-- `docs/theory/solver_2x_sdf/` — the component-split solver (`run.py`,
-  `run_blockage.py`, `run_factors.py`); its `README.md` is the authoritative
-  status/experiment log and maps every file to the physics it owns.
-- `docs/theory/demos_gpu/` — demo runs that produce the notebook's figures/GIFs;
-  they import physics from `solver_2x_sdf`, never duplicate it.
-- `docs/theory/kbc_lbm.ipynb` — the write-up; it embeds pre-rendered artefacts and
-  does not execute the simulations.
-- `docs/origins/` — source PDFs behind the theory.
-
-Do not fold this into the CMake build, and do not treat it as dead code — it is
-active research with a documented experiment history.

README.md

@@ -11,16 +11,18 @@ reference grid planes through the origin, with `.obj` model loading and display.
   at the origin.
 * `.obj` loading with three display modes — solid (flat-shaded), wireframe, and
   solid + wireframe overlay.
-* ImGui interface (Viewport controls + Mesh load panel).
+* ImGui interface — two windows, titled `Viewport` and `Mesh`.
 
 All Vulkan code is isolated in `src/vk/`; the rest of the app is Vulkan-free.
 
 ## Targets
 
-* Windows x64 (MSVC / clang-cl)
+* Windows x64 (MSVC)
 * Linux x64 (gcc / clang)
 * macOS arm64 (Apple Silicon, via MoltenVK)
 
+The presets do not pin a compiler — each inherits whatever the environment provides.
+
 ## Prerequisites
 
 * Vulkan SDK 1.3.290+ (`https://vulkan.lunarg.com/`)
@@ -28,6 +30,10 @@ All Vulkan code is isolated in `src/vk/`; the rest of the app is Vulkan-free.
 * Ninja
 * C++20 compiler (MSVC 19.36+, gcc 11+, clang 14+)
 
+Only CMake 3.26 and C++20 are enforced by the build. `find_package(Vulkan)` carries no
+version argument, and the compiler minimums above are recommendations, not checks — the
+de-facto SDK floor comes from the pinned volk and vk-bootstrap 1.3.295.
+
 ## Build
 
 ```sh
@@ -50,8 +56,10 @@ ctest --preset windows-msvc-debug
 ```
 src/
   core/    Logger, Window, App (orchestration, Vulkan-free)
-  vk/      All Vulkan: Context, Swapchain, Buffer, Image, Shader, GpuMesh,
+  vk/      All Vulkan: Context, Swapchain, Shader, GpuMesh,
            Renderer (frame loop + depth + ImGui), MeshRenderer, GridRenderer
+           (Buffer and Image are also built here but used by nobody — the
+            renderers call VMA directly)
   mesh/    CPU mesh: tinyobjloader + welding (no Vulkan)
   editor/  Camera, mouse input, EditorUI + MeshLoadPanel (ImGui, no Vulkan)
   app/     main.cpp

docs/rust_vs_cpp.md

@@ -0,0 +1,416 @@
+# Rust против C++: две версии редактора SimVulcan
+
+Ветка `rust` содержит порт редактора с C++20 на Rust. Обе версии лежат в дереве рядом,
+собираются независимо и делают одно и то же. Этот документ — не выбор победителя, а
+разложенные факты: что изменилось, чего это стоило и что померилось.
+
+## Что именно сравнивается
+
+Программа одна и та же: окно 1280×720, орбитальная камера вокруг начала координат, три
+опорные плоскости сетки и цветные оси XYZ, загрузка `.obj` в отдельном потоке, сварка
+вершин с допуском `1e-4`, три режима отображения модели, единый проход динамического
+рендеринга с глубинным вложением, submit через `synchronization2`, два кадра в полёте.
+
+**Общее:** каталог `shaders/` — обе версии компилируют одни и те же `.vert`/`.frag` тем
+же `glslangValidator -V --target-env vulkan1.3`; каталог `assets/` — одни и те же модели.
+
+**Разное по договорённости:** интерфейс. В C++ это Dear ImGui, в Rust — **egui**. Крейт
+`imgui` существует, но это биндинги: сборка всё равно тянула бы ~40 тыс. строк C++ через
+`cc`, и «Rust-версия», компилирующая C++, обесценила бы сравнение экосистем. Панели
+из-за этого выглядят иначе; набор элементов управления тот же.
+
+## Условия замеров
+
+| | |
+|---|---|
+| машина | Intel Core i5-1135G7, 4 ядра / 8 потоков, 16 ГБ, SSD |
+| видео | Intel Iris Xe, драйвер 31.0.101.5186, экран 60 Гц |
+| ОС | Windows 11 Home 10.0.26200 |
+| C++ | MSVC 14.50.35717 (VS 18 BuildTools), CMake 4.3.2, Ninja 1.13.2 |
+| Rust | rustc / cargo 1.97.1, MSVC-ABI |
+| общее | Vulkan SDK 1.4.341.1 |
+
+Обе сборки — релизные (`CMAKE_BUILD_TYPE=Release`; `cargo --release` с `lto = "thin"`,
+`codegen-units = 1`). Обе однопоточно ограничены одним и тем же железом; замеры сделаны
+подряд, без других нагрузок.
+
+## Цифры
+
+### Сборка
+
+Все числа C++ уменьшены на 3.0 с — накладные расходы `vcvars64.bat`, который приходится
+вызывать в каждом сеансе (замерены отдельно, среднее из трёх). У `cargo` такого нет.
+
+| | C++ | Rust |
+|---|---|---|
+| конфигурация (исходники зависимостей на месте) | 9.7 с | входит в сборку |
+| **release с нуля** | **114 с** | **194 с** (thin LTO) · 182 с (без LTO) |
+| release, ничего не менялось | 1.1 с | 1.0 с |
+| **release после правки одного файла** | **4.4 с** | **52.3 с** (thin LTO) · 5.5 с (без LTO) |
+| debug с нуля | 112 с | 83 с |
+| debug после правки одного файла | 8.0 с | 5.2 с |
+
+Правился в обоих случаях самый крупный файл Vulkan-слоя: `src/vk/Renderer.cpp` и
+`crates/simv-vk/src/renderer.rs`.
+
+Две оговорки, без которых таблица врёт.
+
+**Уровни оптимизации разные.** `CMAKE_BUILD_TYPE=Release` у MSVC — это `/O2` без
+оптимизации всей программы (CMake не включает `INTERPROCEDURAL_OPTIMIZATION` сам).
+Профиль порта просит `lto = "thin"` и `codegen-units = 1`, то есть межкрейтовую
+оптимизацию. Отсюда и 52 секунды на инкрементальную пересборку: правка одной строки
+заставляет заново оптимизировать и слинковать весь бинарь. Колонка «без LTO» —
+`CARGO_PROFILE_RELEASE_LTO=false`, `CODEGEN_UNITS=16`, то есть примерный аналог `/O2`
+без LTCG: **5.5 с против 4.4 с**, и разницы уже нет. Инкрементальная сборка в Rust
+медленная не сама по себе, а ровно настолько, насколько её просят оптимизировать.
+
+**«С нуля» здесь не значит «с чистой машины».** Обе цифры сняты при уже скачанных
+зависимостях. Честная холодная сборка C++ до конца не дошла: `FetchContent` клонирует
+девять репозиториев с полной историей, и на этом соединении она за пятнадцать минут
+успела скачать два из них (glfw 24 МБ, glm 100 МБ) и была прервана. Готовое дерево
+зависимостей от отладочной сборки занимает **775 МБ**, и общего кэша у FetchContent нет:
+каждый новый каталог сборки скачивает всё заново. Реестр cargo, наоборот, один на
+пользователя.
+
+### Артефакты и зависимости
+
+| | C++ | Rust |
+|---|---|---|
+| `SimVulcan.exe`, release | **1.18 МБ** | **5.80 МБ** |
+| `SimVulcan.exe`, debug | 5.68 МБ | 28.97 МБ |
+| каталог сборки | 78 МБ | 469 МБ |
+| объявлено зависимостей | 9 | 15 |
+| всего пакетов в графе | 9 | **82** |
+| исходники зависимостей на диске | **~400 МБ** на каждый каталог сборки | **80 МБ** в общем реестре |
+
+Пятикратная разница в размере бинаря — это в основном статически влинкованная стандартная
+библиотека Rust и форматирование `core::fmt`; C++-версия тянет CRT из системы. Разница в
+числе пакетов (82 против 9) впечатляет ровно до того момента, как посмотреть на объём:
+82 крейта Rust занимают в пять раз меньше места, чем девять библиотек C++, потому что
+`.crate` — это архив выпуска, а `FetchContent` — клон с историей.
+
+> **Поправка.** В первой редакции здесь стояли «775 МБ» и «10 пакетов». Обе цифры сняты
+> с каталога `build/`, сконфигурированного из другого дерева исходников: его `_deps/`
+> содержит 262 МБ `nlohmann_json`, которого этот проект не объявляет. Девять объявленных
+> репозиториев дают около 400 МБ исходников и около 510 МБ всего `_deps` после сборки.
+> Число пакетов Rust получено `cargo tree -e normal` по текущему `Cargo.lock`.
+
+### Выполнение
+
+Обе версии показывают в режиме FIFO на экране 60 Гц, поэтому частота кадров у них
+одинаковая по построению и ничего не измеряет. Сравнимы старт и процессорная стоимость.
+
+| | C++ | Rust |
+|---|---|---|
+| старт до готовности рендерера (лучший из трёх) | 1068 мс | **754 мс** |
+| то же, средний | 1080 мс | 872 мс* |
+| процессорное время при 60 Гц | **11.2%** реального | 12.6% реального |
+
+\* без первого запуска сразу после сборки: он занял 3.4 с, пока система подтягивала
+свежий 5.8-мегабайтный образ с диска. У C++-версии разброс между запусками — 21 мс.
+
+Полтора процента разницы по процессору — это egui против Dear ImGui, а не Rust против
+C++: egui пересобирает раскладку каждый кадр, ImGui хранит её между кадрами. Сцена
+(сетка + модель) в обеих версиях записывается одинаковыми вызовами.
+
+### Совпадают ли результаты
+
+Проверка, что порт считает то же самое: один и тот же файл загружается обеими версиями,
+сравниваются счётчики.
+
+| файл | C++ (tinyobjloader) | Rust (tobj) |
+|---|---|---|
+| `cow.obj` | 2451 вершины, 4898 треугольников | **2451, 4898** |
+| `plane.obj` | 10673 вершины, 20035 треугольников | 10638, **20061** |
+
+`cow.obj` сходится точно. `plane.obj` расходится, и оба расхождения объяснимы:
+
+* **35 вершин.** tinyobjloader отдаёт глобальный массив `attrib.vertices` целиком, включая
+  вершины, на которые не ссылается ни одна грань; tobj такие отбрасывает. Сварка потом
+  всё равно оставила бы их висеть в списке — на картинку они не влияют.
+* **26 треугольников.** В `plane.obj` 119 граней с пятью и более вершинами. tobj режет
+  n-угольник веером, что даёт ровно `n − 2` треугольника — суммарно 20061, и это
+  совпадает с прямым подсчётом по файлу. tinyobjloader для `n ≥ 5` применяет
+  earcut-подобную триангуляцию и выбрасывает выродившиеся треугольники, отсюда 20035.
+  Разница 0.13% и целиком лежит в библиотеке чтения, а не в переносе.
+
+Сварка вершин (`weld_vertices`) перенесена построчно, включая бакетирование округлением
+и FNV-хеш. Все три случая Catch2 перенесены дословно и проходят; сверх них в порт
+добавлены ещё два — бакетирование округлением, а не отбрасыванием, и габариты пустого
+меша.
+
+### Побочная находка: строка, которой не бывает
+
+При сверке счётчиков выяснилось, что C++-версия **никогда не печатает** результат сварки.
+`ObjLoader::LoadObj` пишет `Loaded OBJ '…': N verts, M tris` в категорию `MeshIO`, а
+обработчик в `main.cpp` сразу за ним пишет туда же `Mesh ready: …`. У категории стоит
+троттлинг 0.5 с, оба сообщения уровня `Info` — второе гарантированно отбрасывается.
+В журналах обеих загрузок (`cow.obj` и `plane.obj`) строки `Mesh ready` нет.
+
+Это и стало причиной единственного расхождения в переносе журнала: в порте троттлинг по
+умолчанию выключен, а `set_throttle` включается там, где сообщения идут покадрово.
+Иначе стартовый вывод терял бы имя видеокарты — в C++ он уцелел лишь потому, что
+низкоуровневый код Vulkan пишет напрямую через `spdlog`, минуя категории.
+
+## Строки кода
+
+Считано одинаковыми правилами для обеих версий: строка комментарийная, если после
+обрезки пробелов начинается с `//` (для C++ ещё блочные `/* … */`); хвостовые
+комментарии за кодом не вычитаются.
+
+| модуль | C++ | | | | Rust | | | |
+|---|---|---|---|---|---|---|---|---|
+| | всего | пусто | комм. | **кода** | всего | пусто | комм. | **кода** |
+| журнал, окно (`core`) | 370 | 83 | 11 | **276** | 310 | 36 | 62 | **212** |
+| Vulkan (`vk`) | 2120 | 380 | 88 | **1652** | 2491 | 238 | 255 | **1998** |
+| меш (`mesh`) | 236 | 50 | 14 | **172** | 412 | 51 | 72 | **289** |
+| редактор (`editor`) | 305 | 68 | 20 | **217** | 431 | 48 | 62 | **321** |
+| приложение (`app`) | 85 | 14 | 5 | **66** | 226 | 27 | 43 | **156** |
+| тесты | 65 | 9 | 5 | **51** | *внутри модулей* | | | *176* |
+| **итого** | **3181** | 604 | 143 | **2434** | **3870** | 400 | 494 | **2976** |
+| система сборки | 431 | | | **399** | 232 | | | **197** |
+
+Порт длиннее примерно на пятую часть, и большая часть перевеса — в Vulkan-слое: +346
+строк кода в `simv-vk` — это написанная руками замена vk-bootstrap. Но «почти весь» было
+бы преувеличением: из 542 строк общего перевеса на Vulkan-слой приходится 346 (64 %), а
+внутри него на `Context` + `Swapchain` — 305 (56 % от общего). Остальное настоящее: меш
++117, редактор +104, приложение +90, `core` −64. Приложение выросло с 66 до 156 строк,
+потому что в него переехал `App` из `simv_core` (см. расхождение 1) и поиск каталога
+моделей стал честным обходом предков вместо пяти захардкоженных `../`.
+
+Комментариев в порте втрое больше (494 против 143), и это перекос замера, а не свойство
+языка: значительная их часть — пометки «здесь расхождение с C++-версией и вот почему»,
+написанные ради этого документа. По строкам собственно кода разрыв — 2976 против 2434,
+и он меньше, если вычесть тесты: они в Rust живут внутри модулей (176 строк), в C++ —
+отдельной целью (51 строка).
+
+## Структурные расхождения
+
+Каждое — с причиной. Ни одно не сделано «чтобы было красивее».
+
+### 1. `App` переехал в исполняемый крейт
+
+В C++ цикличны исходники: `core::App` владеет `vk::Renderer`, а `vk::Renderer`
+принимает `core::Window&`. Граф целей CMake при этом ацикличен — потому CMake ни на что
+и не жалуется: `simv_vk` **не линкует** `simv_core`, а видит его заголовки через
+`target_include_directories(simv_vk PUBLIC ..)`, и всё сходится на компоновке
+исполняемого файла. Cargo цикл между крейтами отвергает
+сразу, поэтому `App` (25 строк) поднят на уровень выше обоих — в `simv-app`.
+
+Это единственный пункт, где Rust потребовал перекладывать код, и заодно единственный,
+где он указал на настоящую проблему в исходной раскладке: срез слоёв, который CMake
+пропустил молча.
+
+### 2. Границу модулей проверяет компилятор
+
+Главный инвариант проекта — «весь Vulkan живёт в `src/vk/`» — в C++ держится на
+дисциплине и записи в `CLAUDE.md`: ничто не мешает написать `#include <volk.h>` в
+`mesh/ObjLoader.cpp`, все заголовки видны. В порте `simv-mesh` и `simv-editor` просто не
+имеют `ash` в зависимостях: нарушение не соберётся.
+
+Побочный эффект: `EditorUI` не может назвать тип `vk::RenderMode`. C++ обходит ту же
+границу, возвращая из панели голый `int`, который `main.cpp` приводит
+`static_cast<vk::RenderMode>` — связь двух перечислений там держится на честном слове.
+В порте у панели свой `DisplayMode`, а разбор делает `match` в `simv-app`: добавится
+вариант — компилятор укажет место.
+
+### 3. pImpl не понадобился
+
+`vk::Renderer` в C++ прячет всё за `struct Renderer::Impl` и `unique_ptr` ради одного:
+чтобы заголовок не тащил volk в трансляционные единицы `App` и `main`. В Rust заголовков
+нет, и приватные поля модуля дают ту же изоляцию бесплатно — минус один уровень
+косвенности и минус ручное объявление/определение `Impl` на 45 строк.
+
+### 4. Замыкание интерфейса стало параметром, а состояние — возвратом
+
+В C++ `Renderer` хранит `std::function<void()>`, а замыкание из `main.cpp` захватывает по
+ссылке камеру, панели и **сам рендерер**, чтобы вызвать `SetViewProj`, `SetRenderMode`,
+`SetGridVisible`. В Rust так нельзя: замыкание вызывается из метода рендерера, то есть
+рендерер оказался бы одолжен дважды.
+
+Решение: замыкание передаётся параметром в `draw_frame` и **возвращает** `FrameState`
+с матрицей вида-проекции, режимом и видимостью сетки. Состояние применяется к тому же
+кадру, отставания нет. Сеттеры исчезли за ненадобностью.
+
+```cpp
+// C++: состояние ставится изнутри колбэка
+app.SetUiCallback([&]() {
+    editorUI.Draw(camera);
+    renderer.SetViewProj(camera.ViewProj(renderer.AspectRatio()));
+});
+```
+
+```rust
+// Rust: состояние возвращается из замыкания
+renderer.draw_frame(window, |ctx| {
+    editor_ui.draw(ctx, camera);
+    FrameState { view_proj: camera.view_proj(aspect), .. }
+})?;
+```
+
+### 5. Выгрузка меша уехала из середины кадра
+
+В C++ панель загрузки зовёт `OnLoaded` прямо из `Draw`, то есть из середины
+`Renderer::DrawFrame`, **уже после** `vkAcquireNextImageKHR`. Обработчик оттуда дёргает
+`SetMeshCpu`, а тот — `vkDeviceWaitIdle` и выгрузку на видеокарту. Законно, но ждать
+простоя устройства посреди записи кадра — сомнительно.
+
+В Rust это невозможно по той же причине, что и пункт 4. Панель складывает готовый меш в
+поле, приложение забирает его после кадра. Ограничение языка здесь вынесло тяжёлую
+операцию из горячего пути — не потому, что кто-то это заметил.
+
+### 6. `Buffer` и `Image` перестали быть мёртвым грузом
+
+В C++ обе обёртки собираются в цель `simv_vk`, но **ими не пользуется никто**: и
+`GridRenderer`, и `GpuMesh`, и глубинное вложение `Renderer` создают ресурсы прямыми
+вызовами VMA. Это 200 строк, которые компилируются каждую сборку и никогда не работают.
+В порте на них построены все три потребителя — не из-за языка, а потому что порт писался,
+когда потребители уже известны. С gpu-allocator обёртка ещё и обязательна по существу:
+она держит `Allocation`, который иначе пришлось бы освобождать руками в каждом `Drop`.
+
+### 7. Асинхронная загрузка: `mpsc` вместо `std::future`
+
+`LoadObjAsync` в C++ возвращает `std::future<Mesh>`, и исключение из рабочего потока
+всплывает при `get()`. В порте поток шлёт `Result<Mesh, ObjError>` по каналу, панель
+опрашивает `try_recv()`. Разница не в количестве кода (его столько же), а в том, что
+ошибка стала значением: пропустить её нельзя, а тип в сигнатуре перечисляет, что вообще
+может пойти не так.
+
+### 8. SPIR-V вшит в исполняемый файл
+
+`build.rs` компилирует шейдеры в `OUT_DIR`, откуда они попадают в бинарь через
+`include_bytes!`. Вместе с этим исчезли: функция `FindSpvPath` с перебором путей, два
+POST_BUILD-шага копирования каталогов в `CMakeLists.txt`, требование запускать редактор
+из его собственного каталога и целый класс ошибок «шейдер не найден» во время выполнения
+— отсутствующий шейдер теперь ломает сборку. Путевых зависимостей осталось две:
+`assets/meshes`, который ищется подъёмом по предкам бинаря и лишь затем — по предкам
+текущего каталога, и `pipeline_cache.bin`, который пишется рядом с бинарём.
+
+### 9. Цикл событий принадлежит библиотеке
+
+GLFW отдаёт цикл приложению (`while (!ShouldClose()) { PollEvents(); DrawFrame(); }`),
+winit забирает его себе и зовёт приложение через `ApplicationHandler`. `Window::ShouldClose`
+и `Window::PollEvents` исчезли, их место заняли `window_event` и `about_to_wait`. Это
+свойство winit, а не Rust: крейт `glfw` существует и сохранил бы прежнюю форму, но он
+такие же биндинги к C, как `imgui`.
+
+## Чего в экосистеме Rust не нашлось
+
+**Замены vk-bootstrap нет.** В C++ выбор физического устройства по требуемым
+возможностям, поиск семейств очередей, проверка наличия слоя валидации и сборка цепочки
+показа — это `vkb::InstanceBuilder`, `vkb::PhysicalDeviceSelector` и
+`vkb::SwapchainBuilder`. В порте всё это написано руками: перебор устройств, чтение
+`PhysicalDeviceFeatures2` с цепочкой `Vulkan12/13Features` и сверка девяти возможностей,
+разбор флагов семейств очередей с проверкой поддержки показа на поверхность, выбор
+формата с откатом на первый доступный, зажим размера и числа образов по возможностям
+поверхности, создание представлений.
+
+Счёт по одним и тем же модулям (`Context` и `Swapchain` целиком, строки кода без пустых и
+комментариев): **301 строка в C++ против 606 в порте**. Эти 305 строк разницы и есть
+главная причина, по которой `simv-vk` вышел длиннее прообраза, — весь остальной перевес
+Vulkan-слоя укладывается в четыре десятка строк.
+
+**Ритм выпусков разный.** `ash` 0.38 вышел в апреле 2024 и с тех пор не обновлялся —
+это не заброшенность (Vulkan 1.3 он покрывает полностью, а генерируемый API стабилен),
+но зафиксировать стоит. `egui` 0.36 и `egui-ash-renderer` 0.13 — август 2026, живее
+некуда, причём вторая обновилась вслед за первой за две недели. Обратная сторона живости
+— поломки: `egui` 0.36 переименовал `Context::run` в `run_ui`, сменил форму
+`TexturesDelta` (карта правок вместо одной на текстуру) и объявил `set_textures`
+устаревшим. Порт писался под 0.36 и учитывает всё это; годичной давности пример из сети
+не собрался бы.
+
+**Мелочи, которые в C++ приходят с библиотекой.** spdlog печатает локальное время из
+коробки; в Rust за форматированной меткой пришлось взять `chrono`. GLM определяется
+одним заголовком; glam — крейт, зато соглашение о пространстве отсечения у него вынесено
+в путь функции (`camera::rh::proj::vulkan::perspective` вместо
+`GLM_FORCE_DEPTH_ZERO_TO_ONE` плюс ручной `p[1][1] *= -1`).
+
+## Где какой язык помог, а где помешал
+
+**Rust помешал — заимствования на границе рендерера.** Пункты 4 и 5 выше: конструкция
+«объект хранит замыкание, которое трогает этот же объект» в C++ пишется не думая, а в
+Rust не компилируется вовсе. Обход занял полчаса и, если честно, дал код лучше исходного
+— но полчаса были потрачены на спор с компилятором, а не на задачу.
+
+**Rust помешал — цепочки pNext.** `push_next` держит `&mut` на вложенную структуру, пока
+жива голова цепочки, поэтому прочитать `f13.synchronization2` при живом
+`PhysicalDeviceFeatures2` компилятор не даёт. В C++ pNext — сырой указатель, и вопроса
+нет. Лечится блоком, который гасит заимствование:
+
+```rust
+let (f13, f12, f10) = {
+    let mut f13 = vk::PhysicalDeviceVulkan13Features::default();
+    let mut f2 = vk::PhysicalDeviceFeatures2::default().push_next(&mut f13) /* … */;
+    unsafe { instance.get_physical_device_features2(handle, &mut f2) };
+    (f13, /* … */ f2.features)
+};
+```
+
+**Rust помог — порядок уничтожения.** В C++ `Renderer::Impl::~Impl` — это двадцать две
+строки ручного разрушения в правильном порядке, и любая перестановка полей в объявлении структуры
+её не сломает, но и не поможет: связи нет. В Rust порядок полей **и есть** порядок
+уничтожения, а `Drop` у каждой обёртки снимает вопрос «а это уже освободили?». Ловушка
+осталась одна и она подписана в коде: `ash::Device` клонируется как таблица функций, а не
+как владеющая ссылка, поэтому контекст обязан объявляться последним.
+
+**Rust помог — ошибки как значения.** `CheckVk(r, where)` в `Renderer.cpp` — это ручная
+проверка каждого вызова с бросанием `runtime_error`. В порте её место занял `?` и
+трейт-расширение на четыре строки, навешивающее имя вызова. Пропустить проверку нельзя:
+`#[must_use]` на `VkResult` не даст.
+
+**Rust помог — незагруженный меш.** В C++ это `GpuMesh` с состоянием «пустой», метод
+`IsValid()` и отдельный флаг `hasMesh` в `Renderer`, которые обязаны быть согласованы.
+В порте — `Option<GpuMesh>`, и рассогласовать нечего.
+
+**Ничья — сам Vulkan.** Записи `vkCmdBeginRendering`, барьеры sync2, сборка конвейеров
+выглядят в обеих версиях почти одинаково, строка в строку. `ash` не пытается быть
+безопасным поверх Vulkan, и это правильно: `unsafe`-блоки локализуют ровно те места, где
+C++ тоже опасен, не притворяясь, что их нет.
+
+## Итог
+
+Кроме одной клетки, ни один замер не даёт разницы в порядок величины, так что решение к
+таблице не сводится. Исключение — инкрементальная сборка release: 52.3 с против 4.4 с,
+это 11.9×, и объясняется оно thin LTO, а не языком (разбор ниже). Следующие по величине
+разрывы уже укладываются в порядок: исходники зависимостей ~5×, размер бинаря 4.9×.
+Что можно утверждать по итогам порта:
+
+**Порт занял примерно на пятую часть больше строк**, и бо́льшая часть перевеса пришлась на
+`simv-vk`. Главная причина названа выше: замены vk-bootstrap нет, и 301 строка
+`Context` с `Swapchain` превратилась в 606 — это 305 строк из 542 общего перевеса, то есть
+чуть больше половины, а весь Vulkan-слой даёт 346 (64 %). Остальной Vulkan-слой — запись
+кадра, барьеры, сборка конвейеров — совпадает почти строка в строку. Если проект растёт
+дальше именно в Vulkan-часть, эта доля перевеса разовая: инициализация пишется один раз.
+
+**Сборка: паритет везде, кроме одной клетки.** Полная сборка release у C++ вдвое быстрее
+(114 с против 194 с), полная debug — наоборот, медленнее (112 с против 83 с),
+инкрементальная в debug у Rust быстрее (5.2 с против 8.0 с). Единственная резкая
+клетка — инкрементальная release: 52 с против 4.4 с. Это цена thin LTO, а не языка: со
+сравнимым уровнем оптимизации (LTO выключен, как у MSVC `/O2` без LTCG) те же 5.5 с
+против 4.4 с. Практический вывод простой — держать в профиле разработки LTO выключенным,
+включая его только для выпуска.
+
+**Четыре дефекта в C++-версии нашлись при переносе, и ни один не искали.** Цикл в графе
+целей CMake, который проходит только из-за незалинкованной цели. Выгрузка меша с
+`vkDeviceWaitIdle` посреди записи кадра. Рассогласование `GpuMesh::IsValid()` и флага
+`hasMesh` — два источника правды об одном. Строка `Mesh ready`, которую троттлинг
+категории `MeshIO` отбрасывает всегда, так что счётчики после сварки не печатались
+никогда. Первое стало ошибкой сборки, второе — невозможным, третье — невыразимым,
+четвёртое всплыло при сверке чисел.
+
+**И двести строк мёртвого кода.** `Buffer` и `Image` собираются каждую сборку и никем не
+используются. Это не про язык, а про то, что переписывание само по себе работает как
+аудит.
+
+**Цена — время на границах.** Замыкание, которое трогает объект, из чьего метода оно
+вызвано; цепочки pNext, держащие заимствование; порядок уничтожения полей. Каждое место
+решается за полчаса, каждое решение оказывается не хуже исходного, но полчаса уходят на
+разговор с компилятором, а не на задачу.
+
+**Экосистема разнородна.** `egui` и его Vulkan-бэкенд выпускаются раз в месяц и ломают
+API; `ash` не менялся два года и не собирается. Замены vk-bootstrap нет вовсе. В C++
+FetchContent тянет девять библиотек по фиксированным тегам и не имеет общего кэша: каждый
+свежий каталог сборки скачивает их заново.
+
+Выбор языка — за вами. Этот документ фиксирует только то, что удалось измерить и показать
+на коде.

docs/theory/solver_2x_sdf/README.md

@@ -31,8 +31,10 @@
 ## Где какая математика (для ревизии)
 
 - **Столкновение** — `collision.py`. KBC-N1: `f ← f − β(2Δs + γΔh)`, где `Δs = Ps·(f−feq)` —
-  проекция на сдвиг-моменты, `γ` — энтропийный лимитер. Чтобы поэкспериментировать:
+  проекция на сдвиг-моменты, `γ` — энтропийный лимитер. Оператор жёстко зафиксирован:
-  переключить `cfg.collision="bgk"`, либо добавить TRT новой функцией и зарегистрировать в `get`.
+  модуль объявляет `collide = kbc_collide`, поля `cfg.collision` и реестра операторов
+  не существует (см. раздел «Статус» ниже). Чтобы поэкспериментировать с BGK или TRT,
+  придётся вводить и то и другое — это осознанно не сделано.
 - **Перенос** — `streaming.py`. Чистая пул-схема; на физику влияет только корректность сдвигов.
 - **Силы** — `forces.py`. Обмен импульсом по линкам тела:
   `F = Σ_links c_i (f_i^{после столкн.} + f_ī^{после стриминга})`. Второй член — из поля ПОСЛЕ

rust/Cargo.toml

@@ -0,0 +1,42 @@
+# Порт редактора SimVulcan на Rust. Пять крейтов повторяют карту целей CMake из
+# корня репозитория (simv_core / simv_vk / simv_mesh / simv_editor + исполняемый файл),
+# и это не косметика: главный инвариант проекта — «весь Vulkan живёт в одном месте» —
+# здесь проверяется компилятором. У simv-mesh и simv-editor просто нет ash в
+# зависимостях, так что нарушить границу нельзя даже случайно.
+[workspace]
+resolver = "2"
+members = ["crates/*"]
+
+[workspace.package]
+version = "0.1.0"
+edition = "2021"
+rust-version = "1.82"
+license = "MIT"
+
+# Версии закреплены здесь, крейты ссылаются через `workspace = true`.
+[workspace.dependencies]
+simv-core   = { path = "crates/simv-core" }
+simv-mesh   = { path = "crates/simv-mesh" }
+simv-vk     = { path = "crates/simv-vk" }
+simv-editor = { path = "crates/simv-editor" }
+
+ash               = "0.38"
+ash-window        = "0.13"
+raw-window-handle = "0.6"
+winit             = "0.30"
+gpu-allocator     = { version = "0.28", default-features = false, features = ["vulkan"] }
+egui              = "0.36"
+egui-winit        = { version = "0.36", default-features = false, features = ["wayland", "x11"] }
+egui-ash-renderer = { version = "0.13", features = ["gpu-allocator"] }
+glam              = { version = "0.33", features = ["bytemuck"] }
+tobj              = "4"
+log               = "0.4"
+chrono            = { version = "0.4", default-features = false, features = ["clock", "std"] }
+thiserror         = "2"
+anyhow            = "1"
+bytemuck          = { version = "1", features = ["derive"] }
+
+[profile.release]
+opt-level = 3
+lto = "thin"
+codegen-units = 1

rust/README.md

@@ -0,0 +1,113 @@
+# SimVulcan на Rust
+
+Порт редактора `SimVulcan` с C++20 на Rust. Делает то же самое: орбитальная камера над
+тремя опорными плоскостями сетки, цветные оси XYZ, загрузка `.obj` и три режима
+отображения модели. Тот же Vulkan 1.3 с динамическим рендерингом и synchronization2,
+те же шейдеры.
+
+Существует ради сравнения: обе версии лежат в репозитории рядом и собираются
+независимо. Разбор различий с цифрами — в [`../docs/rust_vs_cpp.md`](../docs/rust_vs_cpp.md).
+
+## Требования
+
+* Rust 1.95+ (проверялось на 1.97.1). В `Cargo.toml` объявлено `rust-version = "1.82"`,
+  но это значение недостижимо: залоченные `egui`, `egui-winit` и `epaint` 0.36.1 сами
+  требуют 1.95, и на 1.82 Cargo обрывается на разрешении зависимостей
+* Vulkan SDK 1.3.290+ — нужен только `glslangValidator` для сборки шейдеров
+  (ищется в `%VULKAN_SDK%\Bin`, затем в `PATH`)
+* Драйвер Vulkan 1.3 с `fillModeNonSolid`
+
+## Сборка и запуск
+
+```sh
+cd rust
+cargo build --release
+./target/release/SimVulcan
+```
+
+Запускать можно из любого каталога. Шейдеры вшиты в исполняемый файл на этапе сборки,
+а `assets/meshes` ищется подъёмом по предкам от самого бинаря и только затем — от
+текущего каталога; в отличие от C++-версии, которой нужен запуск из её собственного
+каталога. В отличие от неё же, `assets/` никуда не копируется: порт находит копию в
+корне репозитория, поднимаясь от `target/<профиль>/`.
+
+Рядом с исполняемым файлом создаётся `pipeline_cache.bin` — сериализованный
+`VkPipelineCache`, он перечитывается при следующем запуске. Файл одноразовый: если
+конвейеры повели себя странно, его можно удалить.
+
+Слой валидации Khronos запрашивается во всех конфигурациях, включая `--release`, — как
+и в C++-версии. Если слоя нет, приложение об этом предупредит и пойдёт дальше.
+
+**Для работы над кодом собирайте `cargo build` без `--release`.** В профиле выпуска стоит
+`lto = "thin"`, и правка одной строки заставляет заново оптимизировать и слинковать весь
+бинарь: 52 секунды против 5 в отладочной сборке. Замеры — в
+[`../docs/rust_vs_cpp.md`](../docs/rust_vs_cpp.md).
+
+## Тесты
+
+```sh
+cargo test
+```
+
+Видеокарта не нужна: габариты меша, сварка вершин (три случая), чтение `Cube.obj` и его
+путь ошибки, пространство отсечения камеры и ограничители наклона и приближения,
+разбор категорий журнала — тринадцать тестов плюс один помеченный `#[ignore]`
+диагностический, тот самый, которым получена таблица расхождения загрузчиков. Чистой
+математикой это, впрочем, не является: тесты загрузчика читают настоящие файлы из
+`assets/meshes` через `$CARGO_MANIFEST_DIR`, поэтому им нужен рабочий клон репозитория.
+Тесты живут прямо в модулях (`#[cfg(test)] mod tests`), отдельной цели под них нет.
+
+## Раскладка
+
+Пять крейтов повторяют карту целей CMake из корня репозитория:
+
+Ниже перечислены сторонние зависимости; вдобавок каждый крейт зависит от тех крейтов
+рабочего пространства, что указаны в скобках.
+
+```
+crates/simv-core/     журнал с категориями, окно      → log, chrono, winit
+crates/simv-mesh/     чтение .obj, сварка, габариты   → glam, tobj, log, thiserror
+                                                        (+ simv-core)
+crates/simv-vk/       весь Vulkan + build.rs          → ash, ash-window, raw-window-handle,
+                      (GLSL → SPIR-V)                   gpu-allocator, egui, egui-winit,
+                                                        egui-ash-renderer, winit, glam,
+                                                        bytemuck, log, thiserror
+                                                        (+ simv-core, simv-mesh)
+crates/simv-editor/   камера, ввод, панели            → egui, glam, log
+                                                        (+ simv-core, simv-mesh)
+crates/simv-app/      App и точка входа               → четыре крейта выше
+                                                        + egui, winit, glam, log, anyhow
+```
+
+Главный инвариант проекта — «весь Vulkan живёт в одном месте» — здесь проверяет
+компилятор: у `simv-mesh` и `simv-editor` в зависимостях нет ни `ash`, ни `simv-vk`,
+так что нарушить границу нельзя даже по невнимательности.
+
+Шейдеры общие с C++-версией: `build.rs` крейта `simv-vk` компилирует
+`../../../shaders/editor/*.{vert,frag}` тем же `glslangValidator -V --target-env vulkan1.3`
+и кладёт SPIR-V в `OUT_DIR`, откуда он попадает в бинарь через `include_bytes!`.
+
+## Чем отличается от C++-версии
+
+Снаружи — почти ничем, кроме внешнего вида панелей: вместо Dear ImGui взят **egui**.
+Причина: крейт `imgui` — это биндинги, и сборка всё равно тянула бы за собой исходники
+Dear ImGui на C++, что обесценило бы сравнение.
+
+Внутри отличия сведены в отдельный документ, здесь только самые заметные:
+
+* **`App` живёт в исполняемом крейте**, а не в `simv-core`. В C++ цикличны исходники
+  (`core::App` владеет `vk::Renderer`, `vk::Renderer` принимает `core::Window&`), тогда
+  как граф целей CMake ацикличен — потому CMake и молчит: `simv_vk` не линкует
+  `simv_core`, а лишь видит его заголовки, и символы `Window` находятся при сборке
+  исполняемого файла. Cargo такую схему отвергает.
+* **Состояние сцены возвращается из замыкания интерфейса**, а не ставится сеттерами.
+  Замыкание вызывается из метода рендерера, поэтому трогать рендерер оттуда нельзя.
+* **Загруженный меш выгружается на видеокарту после кадра**, а не изнутри него, как в
+  C++, где колбэк панели дёргает `vkDeviceWaitIdle` уже после захвата образа цепочки
+  показа — хотя запись команд там ещё не началась, `vkBeginCommandBuffer` идёт позже.
+* **`Buffer` и `Image` задействованы.** В C++ обе обёртки собираются в цель `simv_vk`, но
+  ими не пользуется никто.
+* **Нет pImpl.** Приватные поля модуля дают ту же изоляцию, ради которой в C++ заведён
+  `struct Renderer::Impl`.
+* **Цикл событий принадлежит winit.** `ShouldClose`/`PollEvents` заменены методами
+  `ApplicationHandler`.

rust/crates/simv-app/Cargo.toml

@@ -0,0 +1,25 @@
+# Исполняемый файл. Здесь же живёт App — в C++-версии он лежит в simv_core, но там
+# граф целей цикличен (core владеет vk, vk принимает core::Window), а Cargo цикл
+# отвергает. Подробности — в docs/rust_vs_cpp.md.
+[package]
+name = "simv-app"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+description = "Редактор SimVulcan: сборка окна, рендерера и панелей"
+
+[[bin]]
+name = "SimVulcan"
+path = "src/main.rs"
+
+[dependencies]
+simv-core.workspace = true
+simv-mesh.workspace = true
+simv-vk.workspace = true
+simv-editor.workspace = true
+egui.workspace = true
+winit.workspace = true
+glam.workspace = true
+log.workspace = true
+anyhow.workspace = true

rust/crates/simv-app/src/app.rs

@@ -0,0 +1,205 @@
+//! Владелец времени жизни: окно, рендерер, камера, панели — перенос `simv::core::App`
+//! вместе с обвязкой из `main.cpp`.
+//!
+//! Живёт в исполняемом крейте, а не в `simv-core`, где ему соответствовал бы прообраз.
+//! Причина в графе зависимостей: в C++ `simv_core` содержит `App`, который владеет
+//! `vk::Renderer`, а `simv_vk` принимает `core::Window&` — то есть цели ссылаются друг
+//! на друга по кругу. Сходится это лишь потому, что `simv_vk` не линкует `simv_core`, а
+//! видит его заголовки через `target_include_directories`, и всё склеивается на
+//! компоновке исполняемого файла. Cargo цикл между крейтами отвергает, так что `App`
+//! пришлось поднять на уровень выше обоих.
+//!
+//! Второе отличие — сам цикл. У GLFW его пишет приложение
+//! (`while (!ShouldClose()) { PollEvents(); DrawFrame(); }`), у winit цикл владеет
+//! собой и зовёт приложение через `ApplicationHandler`. Кадр по-прежнему рисуется
+//! непрерывно: `about_to_wait` каждый раз просит перерисовку.
+
+use std::path::PathBuf;
+
+use winit::application::ApplicationHandler;
+use winit::event::WindowEvent;
+use winit::event_loop::{ActiveEventLoop, ControlFlow};
+use winit::window::WindowId;
+
+use simv_core::{Window, WindowDesc};
+use simv_editor::{apply_mouse_input, Camera, DisplayMode, EditorUi, MeshLoadPanel};
+use simv_mesh::weld_vertices;
+use simv_vk::{FrameState, RenderMode, Renderer};
+
+/// Допуск сварки вершин после загрузки — как в C++-версии.
+const WELD_TOLERANCE: f32 = 1e-4;
+
+#[derive(Default)]
+pub struct App {
+    window: Option<Window>,
+    renderer: Option<Renderer>,
+    camera: Camera,
+    editor_ui: EditorUi,
+    mesh_panel: MeshLoadPanel,
+    /// Ошибка, из-за которой цикл был прерван. Возвращается из `main` кодом выхода.
+    failure: Option<anyhow::Error>,
+}
+
+impl App {
+    /// Забрать причину аварийного завершения, если она была.
+    pub fn into_result(self) -> anyhow::Result<()> {
+        match self.failure {
+            Some(e) => Err(e),
+            None => Ok(()),
+        }
+    }
+
+    fn fail(&mut self, event_loop: &ActiveEventLoop, error: anyhow::Error) {
+        log::error!(target: "core", "{error:#}");
+        self.failure = Some(error);
+        event_loop.exit();
+    }
+
+    /// Отдать событие интерфейсу. `true` — egui забрал его себе.
+    fn feed_ui(&mut self, event: &WindowEvent) -> bool {
+        let Some(window) = self.window.as_ref() else {
+            return false;
+        };
+        let Some(renderer) = self.renderer.as_mut() else {
+            return false;
+        };
+        renderer.on_window_event(window, event)
+    }
+
+    fn draw(&mut self) -> anyhow::Result<()> {
+        let Some(window) = self.window.as_ref() else {
+            return Ok(());
+        };
+        let Some(renderer) = self.renderer.as_mut() else {
+            return Ok(());
+        };
+        // Отношение сторон внутри замыкания не спросить — рендерер там уже одолжен,
+        // но за кадр оно и не меняется.
+        let aspect = renderer.aspect_ratio();
+
+        let camera = &mut self.camera;
+        let editor_ui = &mut self.editor_ui;
+        let mesh_panel = &mut self.mesh_panel;
+
+        renderer.draw_frame(window, |ctx| {
+            editor_ui.draw(ctx, camera);
+            mesh_panel.draw(ctx);
+            apply_mouse_input(ctx, camera);
+            FrameState {
+                view_proj: camera.view_proj(aspect),
+                render_mode: to_render_mode(editor_ui.display_mode()),
+                grid_visible: editor_ui.grid_visible(),
+            }
+        })?;
+
+        // Готовый меш забирается ПОСЛЕ кадра. В C++ то же самое делалось прямо из
+        // колбэка панели, то есть из середины `DrawFrame`, уже после захвата образа
+        // цепочки показа: `SetMeshCpu` там дёргает `vkDeviceWaitIdle` внутри записи
+        // кадра. Здесь так нельзя (рендерер одолжен), и получилось честнее.
+        if let Some(mut mesh) = mesh_panel.take_loaded() {
+            weld_vertices(&mut mesh, WELD_TOLERANCE);
+            log::info!(
+                target: "mesh",
+                "меш готов: {} вершин, {} треугольников",
+                mesh.vertex_count(),
+                mesh.triangle_count()
+            );
+            renderer.set_mesh_cpu(&mesh)?;
+            // Подогнать камеру под размер модели: она перенесена в начало координат.
+            let radius = 0.5 * (mesh.bbox_max - mesh.bbox_min).length();
+            if radius > 0.0 {
+                camera.set_distance(radius * 2.5);
+            }
+        }
+        Ok(())
+    }
+}
+
+impl ApplicationHandler for App {
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        if self.window.is_some() {
+            return; // возврат из фона — окно уже есть
+        }
+        event_loop.set_control_flow(ControlFlow::Poll);
+
+        let window = match Window::new(event_loop, &WindowDesc::default()) {
+            Ok(w) => w,
+            Err(e) => return self.fail(event_loop, anyhow::anyhow!("не создать окно: {e}")),
+        };
+        let renderer = match Renderer::new(&window) {
+            Ok(r) => r,
+            Err(e) => {
+                return self.fail(event_loop, anyhow::anyhow!("не запустить рендерер: {e}"))
+            }
+        };
+
+        let mesh_dir = find_mesh_directory();
+        log::info!(target: "core", "каталог моделей: {}", mesh_dir.display());
+        self.mesh_panel.set_mesh_directory(mesh_dir);
+
+        self.window = Some(window);
+        self.renderer = Some(renderer);
+        log::info!(target: "core", "SimVulcan запущен. Закройте окно, чтобы выйти.");
+    }
+
+    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
+        self.feed_ui(&event);
+
+        match event {
+            WindowEvent::CloseRequested => event_loop.exit(),
+            WindowEvent::RedrawRequested => {
+                if let Err(e) = self.draw() {
+                    self.fail(event_loop, e);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
+        if let Some(window) = &self.window {
+            window.request_redraw();
+        }
+    }
+
+    fn exiting(&mut self, _event_loop: &ActiveEventLoop) {
+        if let Some(renderer) = &self.renderer {
+            renderer.wait_idle();
+        }
+    }
+}
+
+/// Панель редактора не знает про `simv_vk` (крейт ей недоступен), поэтому разбор
+/// делается здесь. Добавите вариант в [`DisplayMode`] — компилятор укажет на этот
+/// `match`; в C++ на его месте `static_cast<vk::RenderMode>(int)`, который смолчит.
+fn to_render_mode(mode: DisplayMode) -> RenderMode {
+    match mode {
+        DisplayMode::Solid => RenderMode::Solid,
+        DisplayMode::Wireframe => RenderMode::Wireframe,
+        DisplayMode::SolidWire => RenderMode::SolidWire,
+    }
+}
+
+/// Найти `assets/meshes`, поднимаясь от исполняемого файла, а затем от текущего
+/// каталога.
+///
+/// C++-версия перебирает пять относительных путей вида `../../../../../assets/meshes`
+/// от текущего каталога — то есть работает, только если запускать из каталога бинаря.
+/// Здесь отсчёт идёт в первую очередь от самого бинаря, так что запуск из любого места
+/// находит модели. Шейдеров этот поиск не касается: они вшиты в исполняемый файл.
+fn find_mesh_directory() -> PathBuf {
+    let mut roots: Vec<PathBuf> = Vec::new();
+    if let Ok(exe) = std::env::current_exe() {
+        roots.extend(exe.ancestors().map(PathBuf::from));
+    }
+    if let Ok(cwd) = std::env::current_dir() {
+        roots.extend(cwd.ancestors().map(PathBuf::from));
+    }
+    for root in roots {
+        let candidate = root.join("assets").join("meshes");
+        if candidate.is_dir() {
+            return candidate;
+        }
+    }
+    PathBuf::from("assets/meshes")
+}

rust/crates/simv-app/src/main.rs

@@ -0,0 +1,21 @@
+//! Точка входа редактора SimVulcan — перенос `src/app/main.cpp`.
+//!
+//! В C++ здесь же собирается вся обвязка редактора: поиск каталога моделей, обработчик
+//! загрузки, UI-колбэк. Всё это переехало в [`app::App`], потому что при модели
+//! событий winit его методы и есть тело цикла.
+
+mod app;
+
+use winit::event_loop::EventLoop;
+
+fn main() -> anyhow::Result<()> {
+    simv_core::logger::init();
+
+    let event_loop = EventLoop::new()?;
+    let mut app = app::App::default();
+    event_loop.run_app(&mut app)?;
+
+    // Ошибка, из-за которой цикл прервался, возвращается сюда: в отличие от
+    // C++-версии её не приходится ловить `catch (...)` — она пришла значением.
+    app.into_result()
+}

rust/crates/simv-core/Cargo.toml

@@ -0,0 +1,13 @@
+# Аналог цели simv_core: журнал и окно. Vulkan сюда не входит и входить не должен.
+[package]
+name = "simv-core"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+description = "Журнал с категориями и окно — общая основа редактора"
+
+[dependencies]
+log.workspace = true
+chrono.workspace = true
+winit.workspace = true

rust/crates/simv-core/src/lib.rs

@@ -0,0 +1,13 @@
+//! Общая основа редактора: журнал и окно.
+//!
+//! Соответствует цели `simv_core` из CMake, но без `App`: в C++ граф целей цикличен
+//! (`core::App` владеет `vk::Renderer`, а `vk::Renderer` принимает `core::Window&`),
+//! и держится это лишь на том, что `simv_vk` видит заголовки `core` через
+//! `target_include_directories`, не линкуя саму цель. Cargo цикл между крейтами
+//! отвергает, поэтому `App` переехал в `simv-app`. Разбор — в `docs/rust_vs_cpp.md`.
+
+pub mod logger;
+pub mod window;
+
+pub use logger::LogCategory;
+pub use window::{Window, WindowDesc};

rust/crates/simv-core/src/logger.rs

@@ -0,0 +1,230 @@
+//! Журнал с категориями, уровнями и троттлингом — перенос `simv::core::Logger`.
+//!
+//! Категории C++-версии легли на target'ы крейта `log`, поэтому писать в журнал
+//! можно обычными макросами:
+//!
+//! ```ignore
+//! log::info!(target: "vk", "контекст готов: {}", name);
+//! ```
+//!
+//! Выигрыш против C++-версии, где `LogFmt` знал только про свои вызовы: под тот же
+//! фильтр и троттлинг автоматически попадают сообщения зависимостей, которые тоже
+//! пишут через `log`. Незнакомый target считается категорией `Core` — так опечатка
+//! в имени не выбрасывает сообщение мимо всех настроек.
+
+use std::io::Write;
+use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU8, Ordering};
+use std::sync::{LazyLock, OnceLock};
+use std::time::Instant;
+
+use log::{Level, LevelFilter, Log, Metadata, Record};
+
+/// Категории журнала. Порядок и имена — как в C++-версии.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum LogCategory {
+    Core,
+    Vulkan,
+    MeshIo,
+    Ui,
+    Test,
+}
+
+impl LogCategory {
+    pub const ALL: [LogCategory; 5] = [
+        LogCategory::Core,
+        LogCategory::Vulkan,
+        LogCategory::MeshIo,
+        LogCategory::Ui,
+        LogCategory::Test,
+    ];
+
+    /// Строка, которую передают в `target:` у макросов `log`.
+    pub const fn target(self) -> &'static str {
+        match self {
+            LogCategory::Core => "core",
+            LogCategory::Vulkan => "vk",
+            LogCategory::MeshIo => "mesh",
+            LogCategory::Ui => "ui",
+            LogCategory::Test => "test",
+        }
+    }
+
+    const fn index(self) -> usize {
+        match self {
+            LogCategory::Core => 0,
+            LogCategory::Vulkan => 1,
+            LogCategory::MeshIo => 2,
+            LogCategory::Ui => 3,
+            LogCategory::Test => 4,
+        }
+    }
+
+    /// Разбор target'а. Крейты-зависимости пишут в свои target'ы («wgpu_hal», «winit»
+    /// и подобные) — они попадают в `Core` и подчиняются её настройкам.
+    fn from_target(target: &str) -> LogCategory {
+        // Зависимости пишут в target'ы вида «egui_winit::state», берём корень.
+        let root = target.split("::").next().unwrap_or(target);
+        match root {
+            "vk" => LogCategory::Vulkan,
+            "mesh" => LogCategory::MeshIo,
+            "ui" => LogCategory::Ui,
+            "test" => LogCategory::Test,
+            _ => LogCategory::Core,
+        }
+    }
+}
+
+/// Настройки одной категории. Меняются в любой момент из любого потока — ровно то,
+/// что в C++-версии делали `SetMinLevel` / `SetThrottle` / `SetEnabled`.
+struct CategoryState {
+    enabled: AtomicBool,
+    /// `LevelFilter as u8`: Off=0, Error=1, … Trace=5.
+    min_level: AtomicU8,
+    throttle_ms: AtomicI64,
+    /// `i64::MIN` — в этой категории ещё ничего не печатали.
+    last_log_ms: AtomicI64,
+}
+
+impl CategoryState {
+    const fn new() -> Self {
+        Self {
+            enabled: AtomicBool::new(true),
+            min_level: AtomicU8::new(LevelFilter::Info as u8),
+            // C++-версия ставит по умолчанию 0.5 с на категорию, но её низкоуровневый
+            // код Vulkan пишет прямо через spdlog, минуя категории, поэтому стартовые
+            // сообщения там всё равно печатаются все. Здесь через категории идёт ВСЁ,
+            // и тот же порог съедал бы половину стартового вывода: имя видеокарты и
+            // размер кэша конвейеров приходят в пределах одной сотой секунды.
+            // Поведение приложения важнее буквы: по умолчанию не троттлим,
+            // `set_throttle` включает порог там, где сообщения идут покадрово.
+            throttle_ms: AtomicI64::new(0),
+            last_log_ms: AtomicI64::new(i64::MIN),
+        }
+    }
+}
+
+static CATEGORIES: [CategoryState; 5] = [
+    CategoryState::new(),
+    CategoryState::new(),
+    CategoryState::new(),
+    CategoryState::new(),
+    CategoryState::new(),
+];
+
+static EPOCH: LazyLock<Instant> = LazyLock::new(Instant::now);
+static LOGGER: SimvLogger = SimvLogger;
+static INIT: OnceLock<()> = OnceLock::new();
+
+fn now_ms() -> i64 {
+    EPOCH.elapsed().as_millis() as i64
+}
+
+struct SimvLogger;
+
+impl Log for SimvLogger {
+    fn enabled(&self, metadata: &Metadata<'_>) -> bool {
+        // Дешёвая проверка до форматирования аргументов. Троттлинг сюда не попадает
+        // намеренно: у него есть побочный эффект, а `enabled` вызывается и просто так.
+        let state = &CATEGORIES[LogCategory::from_target(metadata.target()).index()];
+        state.enabled.load(Ordering::Relaxed)
+            && (metadata.level() as u8) <= state.min_level.load(Ordering::Relaxed)
+    }
+
+    fn log(&self, record: &Record<'_>) {
+        if !self.enabled(record.metadata()) {
+            return;
+        }
+        let category = LogCategory::from_target(record.target());
+        let state = &CATEGORIES[category.index()];
+
+        // Предупреждения и ошибки троттлинг обходят: пропустить их — хуже, чем
+        // залить ими вывод.
+        let important = record.level() <= Level::Warn;
+        if !important {
+            let throttle = state.throttle_ms.load(Ordering::Relaxed);
+            if throttle > 0 {
+                let now = now_ms();
+                let last = state.last_log_ms.load(Ordering::Relaxed);
+                if last != i64::MIN && (now - last) < throttle {
+                    return;
+                }
+                state.last_log_ms.store(now, Ordering::Relaxed);
+            }
+        }
+
+        let (name, color) = match record.level() {
+            Level::Error => ("error", "\x1b[31;1m"),
+            Level::Warn => ("warning", "\x1b[33;1m"),
+            Level::Info => ("info", "\x1b[32m"),
+            Level::Debug => ("debug", "\x1b[36m"),
+            Level::Trace => ("trace", "\x1b[90m"),
+        };
+        let stamp = chrono::Local::now().format("%H:%M:%S%.3f");
+
+        let mut out = std::io::stdout().lock();
+        let _ = writeln!(
+            out,
+            "[{stamp}] [{color}{name}\x1b[0m] [{}] {}",
+            category.target(),
+            record.args()
+        );
+    }
+
+    fn flush(&self) {
+        let _ = std::io::stdout().flush();
+    }
+}
+
+/// Подключить журнал. Повторные вызовы безвредны — выигрывает первый.
+pub fn init() {
+    INIT.get_or_init(|| {
+        LazyLock::force(&EPOCH);
+        // Глобальный порог держим открытым: решение принимает фильтр по категориям.
+        log::set_max_level(LevelFilter::Trace);
+        // Ошибка означает, что журнал уже кто-то поставил — ничего страшного.
+        let _ = log::set_logger(&LOGGER);
+    });
+}
+
+/// Порог уровня для категории.
+pub fn set_min_level(category: LogCategory, level: LevelFilter) {
+    CATEGORIES[category.index()]
+        .min_level
+        .store(level as u8, Ordering::Relaxed);
+}
+
+/// Минимальный интервал между сообщениями категории, в секундах. `0` — без троттлинга.
+pub fn set_throttle(category: LogCategory, seconds: f64) {
+    CATEGORIES[category.index()]
+        .throttle_ms
+        .store((seconds * 1000.0) as i64, Ordering::Relaxed);
+}
+
+/// Полностью выключить или включить категорию.
+pub fn set_enabled(category: LogCategory, enabled: bool) {
+    CATEGORIES[category.index()]
+        .enabled
+        .store(enabled, Ordering::Relaxed);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn known_targets_map_to_their_categories() {
+        assert_eq!(LogCategory::from_target("vk"), LogCategory::Vulkan);
+        assert_eq!(LogCategory::from_target("mesh"), LogCategory::MeshIo);
+        // Чужие target'ы зависимостей не теряются, а попадают в Core.
+        assert_eq!(LogCategory::from_target("winit::platform"), LogCategory::Core);
+    }
+
+    #[test]
+    fn every_category_has_a_distinct_index() {
+        let mut seen = [false; 5];
+        for category in LogCategory::ALL {
+            assert!(!seen[category.index()], "индекс {} занят дважды", category.index());
+            seen[category.index()] = true;
+        }
+    }
+}

rust/crates/simv-core/src/window.rs

@@ -0,0 +1,67 @@
+//! Окно — перенос `simv::core::Window`.
+//!
+//! Отличие от C++-версии не в обёртке, а в модели событий. У GLFW цикл пишет
+//! приложение: `while (!ShouldClose()) { PollEvents(); DrawFrame(); }`. У winit цикл
+//! владеет собой сам и зовёт приложение через `ApplicationHandler`, поэтому
+//! `ShouldClose` и `PollEvents` здесь просто нечему соответствовать — они переехали
+//! в `simv_app::App` в виде обработчиков событий.
+//!
+//! Заодно исчез `RequiredInstanceExtensions`: в C++ список расширений спрашивали у
+//! GLFW, в Rust его даёт `ash_window::enumerate_required_extensions` по дескриптору
+//! дисплея, то есть он оказался на стороне графики, а не окна.
+
+use winit::dpi::LogicalSize;
+use winit::error::OsError;
+use winit::event_loop::ActiveEventLoop;
+use winit::window::{Window as WinitWindow, WindowAttributes};
+
+/// Параметры создаваемого окна.
+pub struct WindowDesc {
+    pub title: String,
+    pub width: u32,
+    pub height: u32,
+    pub resizable: bool,
+}
+
+impl Default for WindowDesc {
+    fn default() -> Self {
+        Self {
+            title: "SimVulcan".to_owned(),
+            width: 1280,
+            height: 720,
+            resizable: true,
+        }
+    }
+}
+
+/// Окно приложения.
+pub struct Window {
+    handle: WinitWindow,
+}
+
+impl Window {
+    pub fn new(event_loop: &ActiveEventLoop, desc: &WindowDesc) -> Result<Self, OsError> {
+        let attributes = WindowAttributes::default()
+            .with_title(desc.title.clone())
+            .with_inner_size(LogicalSize::new(desc.width, desc.height))
+            .with_resizable(desc.resizable);
+        Ok(Self {
+            handle: event_loop.create_window(attributes)?,
+        })
+    }
+
+    pub fn raw(&self) -> &WinitWindow {
+        &self.handle
+    }
+
+    /// Размер кадрового буфера в пикселях. Ноль по любой оси означает свёрнутое окно —
+    /// рисовать в этот кадр нельзя.
+    pub fn framebuffer_size(&self) -> (u32, u32) {
+        let size = self.handle.inner_size();
+        (size.width, size.height)
+    }
+
+    pub fn request_redraw(&self) {
+        self.handle.request_redraw();
+    }
+}

rust/crates/simv-editor/Cargo.toml

@@ -0,0 +1,15 @@
+# Аналог цели simv_editor: камера, ввод и панели. Vulkan не видит.
+[package]
+name = "simv-editor"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+description = "Орбитальная камера и панели редактора на egui"
+
+[dependencies]
+simv-core.workspace = true
+simv-mesh.workspace = true
+egui.workspace = true
+glam.workspace = true
+log.workspace = true

rust/crates/simv-editor/src/camera.rs

@@ -0,0 +1,152 @@
+//! Орбитальная камера — перенос `simv::editor::Camera`.
+//!
+//! Смотрит всегда в начало координат; yaw/pitch/расстояние ставят глаз на сферу
+//! вокруг него. Загруженные модели переносятся в центр матрицей модели, так что
+//! отдельной точки интереса у камеры нет.
+//!
+//! Проекция — в пространстве отсечения Vulkan. В C++ это стоит двух отдельных мер:
+//! `#define GLM_FORCE_DEPTH_ZERO_TO_ONE` перед включением заголовка (и надежда, что
+//! никакой другой файл не включит glm раньше без него) плюс ручной переворот
+//! `p[1][1] *= -1` с комментарием, зачем он. У glam соглашение вынесено в путь
+//! функции: `camera::rh::proj::vulkan::perspective` уже даёт и глубину [0, 1], и
+//! Y вниз, так что переворачивать вручную нечего.
+
+use glam::{Mat4, Vec3};
+
+const PITCH_LIMIT: f32 = 1.553_34; // ~89°, чтобы не поймать вырождение look_at
+const MIN_DISTANCE: f32 = 0.5;
+const MAX_DISTANCE: f32 = 200.0;
+
+/// Плоскость, к которой можно развернуть вид кнопкой.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum ViewPlane {
+    /// Спереди: взгляд вдоль −Z, плоскость XY.
+    Front,
+    /// Сверху: взгляд вдоль −Y, плоскость XZ.
+    Top,
+    /// Сбоку: взгляд вдоль −X, плоскость YZ.
+    Side,
+}
+
+pub struct Camera {
+    yaw: f32,
+    pitch: f32,
+    distance: f32,
+}
+
+impl Default for Camera {
+    fn default() -> Self {
+        Self {
+            yaw: 0.6,
+            pitch: 0.5,
+            distance: 8.0,
+        }
+    }
+}
+
+impl Camera {
+    /// Повернуть вокруг цели, в радианах.
+    pub fn orbit(&mut self, d_yaw: f32, d_pitch: f32) {
+        self.yaw += d_yaw;
+        self.pitch = (self.pitch + d_pitch).clamp(-PITCH_LIMIT, PITCH_LIMIT);
+    }
+
+    /// Приблизить или отдалить. Положительное значение (колесо вверх) приближает.
+    pub fn zoom(&mut self, delta: f32) {
+        self.distance = (self.distance * (-delta * 0.15).exp()).clamp(MIN_DISTANCE, MAX_DISTANCE);
+    }
+
+    pub fn set_distance(&mut self, distance: f32) {
+        self.distance = distance.clamp(MIN_DISTANCE, MAX_DISTANCE);
+    }
+
+    pub fn distance(&self) -> f32 {
+        self.distance
+    }
+
+    /// Развернуть вид точно на одну из главных плоскостей.
+    pub fn align_to_plane(&mut self, plane: ViewPlane) {
+        match plane {
+            ViewPlane::Front => {
+                self.yaw = 0.0;
+                self.pitch = 0.0;
+            }
+            ViewPlane::Top => {
+                self.yaw = 0.0;
+                self.pitch = PITCH_LIMIT;
+            }
+            ViewPlane::Side => {
+                self.yaw = std::f32::consts::FRAC_PI_2;
+                self.pitch = 0.0;
+            }
+        }
+    }
+
+    pub fn view(&self) -> Mat4 {
+        let target = Vec3::ZERO;
+        let eye = target
+            + self.distance
+                * Vec3::new(
+                    self.pitch.cos() * self.yaw.sin(),
+                    self.pitch.sin(),
+                    self.pitch.cos() * self.yaw.cos(),
+                );
+        glam::camera::rh::view::look_at_mat4(eye, target, Vec3::Y)
+    }
+
+    /// Проекция в пространстве отсечения Vulkan: глубина [0, 1] и Y вниз.
+    pub fn proj(&self, aspect: f32) -> Mat4 {
+        glam::camera::rh::proj::vulkan::perspective(45.0_f32.to_radians(), aspect, 0.05, 500.0)
+    }
+
+    pub fn view_proj(&self, aspect: f32) -> Mat4 {
+        self.proj(aspect) * self.view()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn pitch_is_clamped_at_the_poles() {
+        let mut camera = Camera::default();
+        camera.orbit(0.0, 100.0);
+        assert!(camera.view().is_finite(), "матрица вида выродилась на полюсе");
+        camera.orbit(0.0, -200.0);
+        assert!(camera.view().is_finite());
+    }
+
+    #[test]
+    fn zoom_stays_within_limits() {
+        let mut camera = Camera::default();
+        for _ in 0..200 {
+            camera.zoom(1.0);
+        }
+        assert!(camera.distance() >= MIN_DISTANCE);
+        for _ in 0..200 {
+            camera.zoom(-1.0);
+        }
+        assert!(camera.distance() <= MAX_DISTANCE);
+    }
+
+    /// Ближняя плоскость обязана лечь в z = 0, дальняя — в z = 1: это и есть
+    /// пространство отсечения Vulkan, а не OpenGL с диапазоном [−1, 1].
+    #[test]
+    fn projection_uses_vulkan_depth_range() {
+        let camera = Camera::default();
+        let p = camera.proj(16.0 / 9.0);
+        let near = p * glam::Vec4::new(0.0, 0.0, -0.05, 1.0);
+        let far = p * glam::Vec4::new(0.0, 0.0, -500.0, 1.0);
+        assert!((near.z / near.w - 0.0).abs() < 1e-4, "ближняя плоскость: {}", near.z / near.w);
+        assert!((far.z / far.w - 1.0).abs() < 1e-4, "дальняя плоскость: {}", far.z / far.w);
+    }
+
+    /// Переворот Y обязателен: без него картинка встанет вверх ногами.
+    #[test]
+    fn projection_flips_y_for_vulkan() {
+        let camera = Camera::default();
+        let p = camera.proj(1.0);
+        assert!(p.y_axis.y < 0.0);
+    }
+}

rust/crates/simv-editor/src/camera_input.rs

@@ -0,0 +1,30 @@
+//! Мышь для камеры — перенос `simv::editor::CameraInput`.
+
+use crate::camera::Camera;
+
+/// Радиан на пиксель перетаскивания — как в C++-версии.
+const ORBIT_SPEED: f32 = 0.01;
+
+/// Множитель колеса.
+///
+/// В ImGui `io.MouseWheel` считает «щелчки»: одна прокрутка — ±1, и C++-версия берёт
+/// половину. egui отдаёт прокрутку в точках, и один щелчок — это примерно пятьдесят.
+/// Отсюда сотая доля: ощущение от колеса остаётся тем же.
+const ZOOM_SPEED: f32 = 0.01;
+
+/// Применить ввод мыши к камере. Ввод, который забрал интерфейс, до сцены не доходит.
+pub fn apply_mouse_input(ctx: &egui::Context, camera: &mut Camera) {
+    if ctx.egui_wants_pointer_input() {
+        return; // указатель над панелью
+    }
+    ctx.input(|input| {
+        if input.pointer.primary_down() {
+            let delta = input.pointer.delta();
+            camera.orbit(delta.x * ORBIT_SPEED, -delta.y * ORBIT_SPEED);
+        }
+        let wheel = input.smooth_scroll_delta.y;
+        if wheel != 0.0 {
+            camera.zoom(wheel * ZOOM_SPEED);
+        }
+    });
+}

rust/crates/simv-editor/src/lib.rs

@@ -0,0 +1,13 @@
+//! Камера, ввод и панели редактора — соответствует цели `simv_editor`.
+//!
+//! Vulkan отсюда не виден: у крейта нет ни `ash`, ни `simv-vk` в зависимостях.
+
+pub mod camera;
+pub mod camera_input;
+pub mod mesh_load_panel;
+pub mod ui;
+
+pub use camera::{Camera, ViewPlane};
+pub use camera_input::apply_mouse_input;
+pub use mesh_load_panel::MeshLoadPanel;
+pub use ui::{DisplayMode, EditorUi};

rust/crates/simv-editor/src/mesh_load_panel.rs

@@ -0,0 +1,156 @@
+//! Панель загрузки моделей — перенос `simv::editor::MeshLoadPanel`.
+//!
+//! Расхождение с C++-версией — в том, как результат попадает наружу. Там панель
+//! держит `std::function<void(Mesh)>` и зовёт его прямо из `Draw`, то есть из
+//! середины `Renderer::DrawFrame`, уже после `vkAcquireNextImageKHR`. Обработчик в
+//! `main.cpp` из этого колбэка дёргает `renderer.SetMeshCpu`, а тот — `vkDeviceWaitIdle`
+//! и выгрузку на видеокарту. Ждать простоя устройства посреди записи кадра законно,
+//! но сомнительно.
+//!
+//! В Rust так просто не выйдет: замыкание, трогающее рендерер, вызывается из метода
+//! этого же рендерера, то есть рендерер одолжен дважды. Панель вместо колбэка
+//! складывает готовый меш в поле, а приложение забирает его через
+//! [`MeshLoadPanel::take_loaded`] после того, как кадр закончен. Ограничение языка
+//! здесь заодно вынесло выгрузку из середины кадра.
+
+use std::path::{Path, PathBuf};
+
+use simv_mesh::{load_obj_async, Mesh, PendingLoad};
+
+pub struct MeshLoadPanel {
+    mesh_dir: PathBuf,
+    obj_files: Vec<String>,
+    selected: Option<usize>,
+    status: String,
+    pending: Option<PendingLoad>,
+    loaded: Option<Mesh>,
+    open: bool,
+}
+
+impl Default for MeshLoadPanel {
+    fn default() -> Self {
+        let mut panel = Self {
+            mesh_dir: PathBuf::from("assets/meshes"),
+            obj_files: Vec::new(),
+            selected: None,
+            status: String::new(),
+            pending: None,
+            loaded: None,
+            open: true,
+        };
+        panel.rescan_files();
+        panel
+    }
+}
+
+impl MeshLoadPanel {
+    pub fn set_mesh_directory(&mut self, dir: PathBuf) {
+        self.mesh_dir = dir;
+        self.selected = None;
+        self.rescan_files();
+    }
+
+    /// Забрать загруженный меш, если он готов. Вызывать после кадра.
+    pub fn take_loaded(&mut self) -> Option<Mesh> {
+        self.loaded.take()
+    }
+
+    fn rescan_files(&mut self) {
+        self.obj_files.clear();
+        let Ok(entries) = std::fs::read_dir(&self.mesh_dir) else {
+            return;
+        };
+        for entry in entries.flatten() {
+            if !entry.file_type().is_ok_and(|t| t.is_file()) {
+                continue;
+            }
+            let path = entry.path();
+            // Расширение без учёта регистра: `Cube.obj`, `cube.OBJ`, `Plane.Obj`.
+            let is_obj = path
+                .extension()
+                .and_then(|e| e.to_str())
+                .is_some_and(|e| e.eq_ignore_ascii_case("obj"));
+            if is_obj {
+                if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
+                    self.obj_files.push(name.to_owned());
+                }
+            }
+        }
+        self.obj_files.sort();
+    }
+
+    pub fn draw(&mut self, ctx: &egui::Context) {
+        if !self.open {
+            return;
+        }
+
+        // Опрос незавершённой загрузки на главном потоке.
+        if let Some(pending) = &mut self.pending {
+            if let Some(result) = pending.try_take() {
+                self.pending = None;
+                match result {
+                    Ok(mesh) => {
+                        self.loaded = Some(mesh);
+                        self.status = String::from("Загружено.");
+                    }
+                    Err(e) => self.status = format!("Ошибка: {e}"),
+                }
+            }
+        }
+
+        let mut open = self.open;
+        egui::Window::new("Модель")
+            .open(&mut open)
+            .default_size([360.0, 240.0])
+            .show(ctx, |ui| self.contents(ui));
+        self.open = open;
+    }
+
+    fn contents(&mut self, ui: &mut egui::Ui) {
+        ui.label(egui::RichText::new(format!("Каталог: {}", self.mesh_dir.display())).weak());
+        if ui.small_button("Обновить список").clicked() {
+            self.rescan_files();
+        }
+        ui.separator();
+
+        egui::ScrollArea::vertical()
+            .max_height(120.0)
+            .auto_shrink([false, false])
+            .show(ui, |ui| {
+                for (index, name) in self.obj_files.iter().enumerate() {
+                    if ui
+                        .selectable_label(self.selected == Some(index), name)
+                        .clicked()
+                    {
+                        self.selected = Some(index);
+                    }
+                }
+            });
+
+        let busy = self.pending.is_some();
+        let can_load = self.selected.is_some() && !busy;
+        ui.horizontal(|ui| {
+            if ui
+                .add_enabled(can_load, egui::Button::new("Загрузить"))
+                .clicked()
+            {
+                if let Some(index) = self.selected {
+                    self.status = String::from("Загружаю…");
+                    self.pending = Some(load_obj_async(self.mesh_dir.join(&self.obj_files[index])));
+                }
+            }
+            if busy {
+                ui.label(egui::RichText::new("(идёт загрузка…)").weak());
+            }
+        });
+
+        if !self.status.is_empty() {
+            ui.separator();
+            ui.label(&self.status);
+        }
+    }
+
+    pub fn mesh_directory(&self) -> &Path {
+        &self.mesh_dir
+    }
+}

rust/crates/simv-editor/src/ui.rs

@@ -0,0 +1,80 @@
+//! Панель вьюпорта — перенос `simv::editor::EditorUI`.
+//!
+//! Про [`DisplayMode`]. Панель обязана как-то сообщить рендереру выбранный режим, но
+//! `simv_vk::RenderMode` ей недоступен: `simv-editor` не зависит от `simv-vk`, и это
+//! проверяет компилятор. C++ обходит ту же границу, возвращая из `EditorUI` голый
+//! `int`, который `main.cpp` приводит через `static_cast` к `vk::RenderMode` —
+//! связь между двумя перечислениями там держится на честном слове. Здесь у панели
+//! свой типизированный режим, а разбор в `simv_vk::RenderMode` делает `simv-app`
+//! обычным `match`: добавите вариант — компилятор укажет, где его дописать.
+
+use crate::camera::{Camera, ViewPlane};
+
+/// Как отображать модель. Соответствует `simv_vk::RenderMode`, но живёт по эту
+/// сторону границы модулей.
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
+pub enum DisplayMode {
+    #[default]
+    Solid,
+    Wireframe,
+    SolidWire,
+}
+
+pub struct EditorUi {
+    display_mode: DisplayMode,
+    grid_visible: bool,
+}
+
+impl Default for EditorUi {
+    fn default() -> Self {
+        Self {
+            display_mode: DisplayMode::Solid,
+            grid_visible: true,
+        }
+    }
+}
+
+impl EditorUi {
+    pub fn display_mode(&self) -> DisplayMode {
+        self.display_mode
+    }
+
+    pub fn grid_visible(&self) -> bool {
+        self.grid_visible
+    }
+
+    pub fn draw(&mut self, ctx: &egui::Context, camera: &mut Camera) {
+        egui::Window::new("Viewport")
+            .default_size([280.0, 200.0])
+            .show(ctx, |ui| {
+                ui.label(egui::RichText::new("Камера").weak());
+                ui.horizontal(|ui| {
+                    if ui.button("Спереди").clicked() {
+                        camera.align_to_plane(ViewPlane::Front);
+                    }
+                    if ui.button("Сверху").clicked() {
+                        camera.align_to_plane(ViewPlane::Top);
+                    }
+                    if ui.button("Сбоку").clicked() {
+                        camera.align_to_plane(ViewPlane::Side);
+                    }
+                });
+                ui.label(
+                    egui::RichText::new("Перетаскивание — поворот, колесо — приближение").weak(),
+                );
+
+                ui.separator();
+                ui.label(egui::RichText::new("Отображение модели").weak());
+                ui.radio_value(&mut self.display_mode, DisplayMode::Solid, "Заливка");
+                ui.radio_value(&mut self.display_mode, DisplayMode::Wireframe, "Каркас");
+                ui.radio_value(
+                    &mut self.display_mode,
+                    DisplayMode::SolidWire,
+                    "Заливка с каркасом",
+                );
+
+                ui.separator();
+                ui.checkbox(&mut self.grid_visible, "Показывать сетку");
+            });
+    }
+}

rust/crates/simv-mesh/Cargo.toml

@@ -0,0 +1,16 @@
+# Аналог цели simv_mesh: меш на стороне процессора. Ни ash, ни egui в зависимостях —
+# граница «Vulkan только в simv-vk» держится не дисциплиной, а графом крейтов.
+[package]
+name = "simv-mesh"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+description = "Загрузка OBJ и сварка вершин, без графического API"
+
+[dependencies]
+simv-core.workspace = true
+glam.workspace = true
+tobj.workspace = true
+log.workspace = true
+thiserror.workspace = true

rust/crates/simv-mesh/src/decimator.rs

@@ -0,0 +1,169 @@
+//! Сварка близких вершин — перенос `simv::mesh::WeldVertices`.
+//!
+//! Имя файла в C++-версии (`MeshDecimator`) обещает больше, чем есть: никакого LOD и
+//! прореживания здесь нет, только схлопывание дубликатов по пространственному хешу и
+//! удаление выродившихся треугольников. Название сохранено, чтобы модули двух версий
+//! сопоставлялись один к одному.
+
+use std::collections::HashMap;
+use std::hash::{BuildHasherDefault, Hasher};
+
+use glam::Vec3;
+
+use crate::mesh::Mesh;
+
+/// Ключ ячейки пространственного хеша.
+type CellKey = [i32; 3];
+
+/// Тот же FNV-1a, что в C++-версии.
+///
+/// На результат сварки хеш-функция не влияет — карта точная, ключи целочисленные, —
+/// но брать стандартный SipHash значило бы сравнивать не алгоритмы, а хеши: SipHash
+/// криптостойкий и заметно дороже. FNV перенесён ровно ради того, чтобы замер времени
+/// сварки в отчёте мерил одно и то же в обеих версиях.
+#[derive(Default)]
+struct Fnv1a(u64);
+
+impl Hasher for Fnv1a {
+    fn finish(&self) -> u64 {
+        self.0
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        // Ключ приходит четвёрками байт (три i32), мешаем по 32-битным словам —
+        // так же, как C++-версия мешает три int32.
+        let mut h = if self.0 == 0 { 0xcbf2_9ce4_8422_2325 } else { self.0 };
+        for word in bytes.chunks(4) {
+            let mut v = [0u8; 4];
+            v[..word.len()].copy_from_slice(word);
+            h ^= u32::from_ne_bytes(v) as u64;
+            h = h.wrapping_mul(0x0100_0000_01b3);
+        }
+        self.0 = h;
+    }
+}
+
+type FnvMap = HashMap<CellKey, u32, BuildHasherDefault<Fnv1a>>;
+
+/// Группировка округлением к ближайшему узлу решётки.
+///
+/// Две точки, отстоящие меньше чем на `tolerance`, гарантированно попадают в одну
+/// ячейку, если обе лежат в пределах допуска от общего узла. Бакетирование через
+/// `floor` на границах ячеек ломается, когда числа падают по разные стороны, —
+/// округление и есть стандартное лекарство для сварки по пространственному хешу.
+#[inline]
+fn to_cell(p: Vec3, tolerance: f32) -> CellKey {
+    let t = tolerance as f64;
+    [
+        (p.x as f64 / t).round() as i32,
+        (p.y as f64 / t).round() as i32,
+        (p.z as f64 / t).round() as i32,
+    ]
+}
+
+/// Схлопнуть вершины, отстоящие меньше чем на `tolerance`, переписать индексы и
+/// выбросить треугольники, у которых после этого совпали хотя бы две вершины.
+pub fn weld_vertices(mesh: &mut Mesh, tolerance: f32) {
+    if mesh.positions.is_empty() || tolerance <= 0.0 {
+        return;
+    }
+
+    let mut cell_to_vertex: FnvMap =
+        FnvMap::with_capacity_and_hasher(mesh.positions.len(), BuildHasherDefault::default());
+    let mut welded: Vec<Vec3> = Vec::with_capacity(mesh.positions.len());
+    let mut remap: Vec<u32> = Vec::with_capacity(mesh.positions.len());
+
+    for &p in &mesh.positions {
+        let cell = to_cell(p, tolerance);
+        let index = *cell_to_vertex.entry(cell).or_insert_with(|| {
+            welded.push(p);
+            (welded.len() - 1) as u32
+        });
+        remap.push(index);
+    }
+
+    let mut new_indices = Vec::with_capacity(mesh.indices.len());
+    for tri in mesh.indices.chunks_exact(3) {
+        let a = remap[tri[0] as usize];
+        let b = remap[tri[1] as usize];
+        let c = remap[tri[2] as usize];
+        if a == b || b == c || a == c {
+            continue;
+        }
+        new_indices.extend_from_slice(&[a, b, c]);
+    }
+
+    mesh.positions = welded;
+    mesh.indices = new_indices;
+    mesh.recalculate_bounds();
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Перенос `TEST_CASE("WeldVertices collapses near-duplicate vertices")`.
+    #[test]
+    fn weld_collapses_near_duplicate_vertices() {
+        let mut m = Mesh {
+            // Два треугольника с общим ребром; вершины разведены в пределах допуска.
+            positions: vec![
+                Vec3::new(0.0, 0.0, 0.0),
+                Vec3::new(1.0, 0.0, 0.0),
+                Vec3::new(0.0, 1.0, 0.0),
+                Vec3::new(0.0001, 0.0, 0.0), // ≈ #0
+                Vec3::new(1.0001, 0.0, 0.0), // ≈ #1
+                Vec3::new(1.0, 1.0, 0.0),
+            ],
+            indices: vec![0, 1, 2, 3, 4, 5],
+            ..Default::default()
+        };
+
+        weld_vertices(&mut m, 0.01);
+
+        assert_eq!(m.positions.len(), 4);
+        assert_eq!(m.indices.len(), 6, "оба треугольника обязаны выжить");
+        // Габариты должны совпасть с «настоящей» оболочкой независимо от порядка сварки.
+        assert!((m.bbox_max.x - 1.0001).abs() < 1e-3);
+    }
+
+    /// Перенос `TEST_CASE("WeldVertices drops degenerate triangles")`.
+    #[test]
+    fn weld_drops_degenerate_triangles() {
+        let mut m = Mesh {
+            // Один настоящий треугольник и один вырожденный: все три вершины в допуске.
+            positions: vec![
+                Vec3::new(0.0, 0.0, 0.0),
+                Vec3::new(1.0, 0.0, 0.0),
+                Vec3::new(0.0, 1.0, 0.0),
+                Vec3::new(2.0, 2.0, 0.0),
+                Vec3::new(2.00005, 2.0, 0.0),
+                Vec3::new(2.0, 2.00005, 0.0),
+            ],
+            indices: vec![0, 1, 2, 3, 4, 5],
+            ..Default::default()
+        };
+
+        weld_vertices(&mut m, 0.001);
+
+        assert_eq!(m.indices.len(), 3, "вырожденный треугольник обязан исчезнуть");
+    }
+
+    /// Округление, а не отсечение: точки по разные стороны границы ячейки, но в
+    /// пределах допуска друг от друга, всё равно должны слиться.
+    #[test]
+    fn weld_buckets_by_rounding_not_flooring() {
+        let mut m = Mesh {
+            positions: vec![
+                Vec3::new(0.00999, 0.0, 0.0),
+                Vec3::new(0.01001, 0.0, 0.0),
+                Vec3::new(5.0, 0.0, 0.0),
+            ],
+            indices: vec![0, 1, 2],
+            ..Default::default()
+        };
+        weld_vertices(&mut m, 0.01);
+        assert_eq!(m.positions.len(), 2);
+        assert!(m.indices.is_empty(), "треугольник выродился и должен быть удалён");
+    }
+}

rust/crates/simv-mesh/src/lib.rs

@@ -0,0 +1,13 @@
+//! Меш на стороне процессора: чтение `.obj`, сварка вершин, габариты.
+//!
+//! Соответствует цели `simv_mesh`. Ни `ash`, ни `egui` в зависимостях крейта нет —
+//! в C++ границу «Vulkan только в `src/vk/`» держит дисциплина, здесь её держит
+//! граф зависимостей: нарушение просто не соберётся.
+
+pub mod decimator;
+pub mod mesh;
+pub mod obj_loader;
+
+pub use decimator::weld_vertices;
+pub use mesh::Mesh;
+pub use obj_loader::{load_obj, load_obj_async, ObjError, PendingLoad};

rust/crates/simv-mesh/src/mesh.rs

@@ -0,0 +1,77 @@
+//! Меш на стороне процессора — перенос `simv::mesh::Mesh`.
+
+use glam::Vec3;
+
+/// Суп из треугольников: позиции и индексы по три на треугольник.
+/// Загружается `obj_loader`, при желании прореживается `decimator`, затем уезжает в
+/// `simv_vk::GpuMesh`. Никакого графического API здесь нет и быть не должно.
+#[derive(Clone, Debug, Default)]
+pub struct Mesh {
+    pub positions: Vec<Vec3>,
+    pub indices: Vec<u32>,
+    pub bbox_min: Vec3,
+    pub bbox_max: Vec3,
+}
+
+impl Mesh {
+    pub fn vertex_count(&self) -> usize {
+        self.positions.len()
+    }
+
+    pub fn triangle_count(&self) -> usize {
+        self.indices.len() / 3
+    }
+
+    /// Пуст в смысле «рисовать нечего»: одних вершин без индексов недостаточно.
+    pub fn is_empty(&self) -> bool {
+        self.positions.is_empty() || self.indices.is_empty()
+    }
+
+    /// Пересчитать габаритный ящик. У пустого меша он схлопывается в начало координат —
+    /// так же, как в C++-версии, чтобы камера не уезжала в бесконечность.
+    pub fn recalculate_bounds(&mut self) {
+        if self.positions.is_empty() {
+            self.bbox_min = Vec3::ZERO;
+            self.bbox_max = Vec3::ZERO;
+            return;
+        }
+        let mut lo = Vec3::splat(f32::MAX);
+        let mut hi = Vec3::splat(f32::MIN);
+        for p in &self.positions {
+            lo = lo.min(*p);
+            hi = hi.max(*p);
+        }
+        self.bbox_min = lo;
+        self.bbox_max = hi;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Перенос `TEST_CASE("Mesh::RecalculateBounds finds AABB")`.
+    #[test]
+    fn recalculate_bounds_finds_aabb() {
+        let mut m = Mesh {
+            positions: vec![
+                Vec3::new(-1.0, -2.0, -3.0),
+                Vec3::new(4.0, 5.0, 6.0),
+                Vec3::new(0.5, 0.0, 1.0),
+            ],
+            ..Default::default()
+        };
+        m.recalculate_bounds();
+        assert_eq!(m.bbox_min, Vec3::new(-1.0, -2.0, -3.0));
+        assert_eq!(m.bbox_max, Vec3::new(4.0, 5.0, 6.0));
+    }
+
+    #[test]
+    fn empty_mesh_has_degenerate_bounds() {
+        let mut m = Mesh::default();
+        m.recalculate_bounds();
+        assert_eq!(m.bbox_min, Vec3::ZERO);
+        assert_eq!(m.bbox_max, Vec3::ZERO);
+        assert!(m.is_empty());
+    }
+}

rust/crates/simv-mesh/src/obj_loader.rs

@@ -0,0 +1,153 @@
+//! Загрузка `.obj` — перенос `simv::mesh::ObjLoader`.
+//!
+//! Асинхронный путь устроен иначе, чем в C++. Там `LoadObjAsync` возвращал
+//! `std::future<Mesh>`, и исключение из рабочего потока всплывало на главном при
+//! вызове `get()`. Здесь поток посылает `Result` по каналу, а вызывающий разбирает
+//! его обычным `match` — ошибка стала значением, и потерять её молча уже не выйдет.
+
+use std::path::{Path, PathBuf};
+use std::sync::mpsc::{self, Receiver, TryRecvError};
+
+use glam::Vec3;
+
+use crate::mesh::Mesh;
+
+#[derive(Debug, thiserror::Error)]
+pub enum ObjError {
+    #[error("не удалось разобрать {path}: {source}")]
+    Parse {
+        path: String,
+        #[source]
+        source: tobj::LoadError,
+    },
+    /// Единственный способ, которым канал может закрыться без ответа, — паника в
+    /// рабочем потоке. Отдельный вариант нужен, чтобы панель показала это как ошибку,
+    /// а не висела в состоянии «грузится» вечно.
+    #[error("поток загрузки завершился аварийно")]
+    WorkerDied,
+}
+
+/// Синхронная загрузка: маленькие файлы, тесты.
+///
+/// Расхождение с C++-версией. tinyobjloader отдаёт единый глобальный массив вершин
+/// (`attrib.vertices`), в который индексируют все формы, — C++-код так его и берёт.
+/// tobj режет файл на модели (по объектам и по материалам) и каждой выдаёт свой
+/// массив позиций, поэтому здесь модели склеиваются со сдвигом индексов. Вершины,
+/// общие для соседних моделей, при этом задваиваются: до сварки счётчик вершин будет
+/// больше, чем в C++-версии. `weld_vertices` их схлопывает, так что после сварки —
+/// той самой, которую делает приложение сразу после загрузки, — счётчики совпадают.
+pub fn load_obj(path: &Path) -> Result<Mesh, ObjError> {
+    let options = tobj::LoadOptions {
+        triangulate: true,
+        ignore_points: true,
+        ignore_lines: true,
+        ..Default::default()
+    };
+
+    let (models, _materials) = tobj::load_obj(path, &options).map_err(|source| ObjError::Parse {
+        path: path.display().to_string(),
+        source,
+    })?;
+
+    let mut mesh = Mesh::default();
+    mesh.positions
+        .reserve(models.iter().map(|m| m.mesh.positions.len() / 3).sum());
+    mesh.indices
+        .reserve(models.iter().map(|m| m.mesh.indices.len()).sum());
+
+    for model in &models {
+        let base = mesh.positions.len() as u32;
+        for xyz in model.mesh.positions.chunks_exact(3) {
+            mesh.positions.push(Vec3::new(xyz[0], xyz[1], xyz[2]));
+        }
+        mesh.indices
+            .extend(model.mesh.indices.iter().map(|i| i + base));
+    }
+
+    mesh.recalculate_bounds();
+
+    log::info!(
+        target: "mesh",
+        "загружен OBJ '{}': {} вершин, {} треугольников",
+        path.file_name().unwrap_or(path.as_os_str()).to_string_lossy(),
+        mesh.vertex_count(),
+        mesh.triangle_count()
+    );
+    Ok(mesh)
+}
+
+/// Незавершённая загрузка. Опрашивается на главном потоке — так же, как C++-версия
+/// опрашивала `future` через `wait_for(0ms)`, чтобы обратный вызов (а с ним и выгрузка
+/// на видеокарту) выполнялся на потоке рендера.
+pub struct PendingLoad {
+    receiver: Receiver<Result<Mesh, ObjError>>,
+}
+
+impl PendingLoad {
+    /// `None` — ещё грузится. `Some(..)` — результат готов; повторные вызовы после
+    /// этого снова вернут `Err(WorkerDied)`, поэтому забирать надо один раз.
+    pub fn try_take(&mut self) -> Option<Result<Mesh, ObjError>> {
+        match self.receiver.try_recv() {
+            Ok(result) => Some(result),
+            Err(TryRecvError::Empty) => None,
+            Err(TryRecvError::Disconnected) => Some(Err(ObjError::WorkerDied)),
+        }
+    }
+}
+
+/// Запустить загрузку в отдельном потоке.
+pub fn load_obj_async(path: PathBuf) -> PendingLoad {
+    let (sender, receiver) = mpsc::channel();
+    std::thread::spawn(move || {
+        // Получатель мог уйти вместе с закрытой панелью — это не ошибка.
+        let _ = sender.send(load_obj(&path));
+    });
+    PendingLoad { receiver }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::decimator::weld_vertices;
+
+    fn asset(name: &str) -> PathBuf {
+        // crates/simv-mesh → корень репозитория.
+        Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../../assets/meshes")
+            .join(name)
+    }
+
+    #[test]
+    fn cube_loads_with_twelve_triangles() {
+        let path = asset("Cube.obj");
+        let mut mesh = load_obj(&path).expect("Cube.obj обязан читаться");
+        assert_eq!(mesh.triangle_count(), 12);
+        weld_vertices(&mut mesh, 1e-4);
+        // Куб после сварки — ровно восемь углов и те же двенадцать треугольников.
+        assert_eq!(mesh.vertex_count(), 8);
+        assert_eq!(mesh.triangle_count(), 12);
+    }
+
+    /// Диагностика для сверки с C++-версией: печатает счётчики до и после сварки.
+    /// Запуск: cargo test -p simv-mesh -- --ignored --nocapture weld_counts
+    #[test]
+    #[ignore = "диагностика, не проверка"]
+    fn weld_counts_for_bundled_assets() {
+        for name in ["Cube.obj", "Cube1.obj", "cow.obj", "plane.obj"] {
+            let mut mesh = load_obj(&asset(name)).expect(name);
+            let (v0, t0) = (mesh.vertex_count(), mesh.triangle_count());
+            weld_vertices(&mut mesh, 1e-4);
+            println!(
+                "{name}: до сварки {v0} вершин / {t0} треугольников, после {} / {}",
+                mesh.vertex_count(),
+                mesh.triangle_count()
+            );
+        }
+    }
+
+    #[test]
+    fn missing_file_reports_error_not_panic() {
+        let err = load_obj(Path::new("нет-такого-файла.obj")).unwrap_err();
+        assert!(matches!(err, ObjError::Parse { .. }));
+    }
+}

rust/crates/simv-vk/Cargo.toml

@@ -0,0 +1,26 @@
+# Аналог цели simv_vk: единственный крейт, которому позволено видеть ash.
+# build.rs компилирует общие с C++-версией шейдеры из ../../shaders в SPIR-V.
+[package]
+name = "simv-vk"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+description = "Весь Vulkan: контекст, swapchain, конвейеры, кадр"
+build = "build.rs"
+
+[dependencies]
+simv-core.workspace = true
+simv-mesh.workspace = true
+ash.workspace = true
+ash-window.workspace = true
+raw-window-handle.workspace = true
+gpu-allocator.workspace = true
+egui.workspace = true
+egui-winit.workspace = true
+egui-ash-renderer.workspace = true
+winit.workspace = true
+glam.workspace = true
+bytemuck.workspace = true
+log.workspace = true
+thiserror.workspace = true

rust/crates/simv-vk/build.rs

@@ -0,0 +1,95 @@
+//! Компиляция GLSL в SPIR-V на этапе сборки — аналог `cmake/ShaderCompile.cmake`.
+//!
+//! Шейдеры берутся из общего с C++-версией каталога `shaders/` в корне репозитория:
+//! обе сборки компилируют одни и те же файлы теми же ключами, поэтому расхождение в
+//! картинке нельзя списать на шейдер.
+//!
+//! В отличие от CMake результат не копируется рядом с исполняемым файлом, а зашивается
+//! в бинарь через `include_bytes!`. Отсюда исчезают и `FindSpvPath`, и POST_BUILD-копия,
+//! и требование «запускать из каталога исполняемого файла».
+
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+fn main() {
+    let manifest = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap());
+    let out_dir = PathBuf::from(std::env::var("OUT_DIR").unwrap());
+    // crates/simv-vk → rust → корень репозитория.
+    let shader_root = manifest.join("../../../shaders");
+    let shader_root = shader_root.canonicalize().unwrap_or(shader_root);
+    let editor_dir = shader_root.join("editor");
+
+    println!("cargo:rerun-if-env-changed=VULKAN_SDK");
+    println!("cargo:rerun-if-changed={}", editor_dir.display());
+
+    let compiler = find_glslang();
+
+    let mut sources: Vec<PathBuf> = std::fs::read_dir(&editor_dir)
+        .unwrap_or_else(|e| panic!("не читается каталог шейдеров {}: {e}", editor_dir.display()))
+        .filter_map(|entry| entry.ok().map(|e| e.path()))
+        .filter(|p| {
+            matches!(
+                p.extension().and_then(|e| e.to_str()),
+                Some("vert") | Some("frag")
+            )
+        })
+        .collect();
+    // Порядок обхода каталога зависит от файловой системы — сортируем, чтобы сборка
+    // была воспроизводимой.
+    sources.sort();
+
+    assert!(
+        !sources.is_empty(),
+        "в {} нет ни одного .vert/.frag",
+        editor_dir.display()
+    );
+
+    let out_editor = out_dir.join("editor");
+    std::fs::create_dir_all(&out_editor).unwrap();
+
+    for src in &sources {
+        println!("cargo:rerun-if-changed={}", src.display());
+        let name = src.file_name().unwrap().to_string_lossy().to_string();
+        let dst = out_editor.join(format!("{name}.spv"));
+
+        let output = Command::new(&compiler)
+            .arg("-V")
+            .args(["--target-env", "vulkan1.3"])
+            // glslangValidator требует -I<путь> без пробела.
+            .arg(format!("-I{}", shader_root.display()))
+            .arg("-o")
+            .arg(&dst)
+            .arg(src)
+            .output()
+            .unwrap_or_else(|e| panic!("не запускается {}: {e}", compiler.display()));
+
+        if !output.status.success() {
+            panic!(
+                "GLSL → SPIR-V не удалось для {}:\n{}{}",
+                src.display(),
+                String::from_utf8_lossy(&output.stdout),
+                String::from_utf8_lossy(&output.stderr)
+            );
+        }
+    }
+}
+
+/// Ищем компилятор там же, где его ищет CMake: сначала в Vulkan SDK, потом в PATH.
+fn find_glslang() -> PathBuf {
+    let exe = if cfg!(windows) {
+        "glslangValidator.exe"
+    } else {
+        "glslangValidator"
+    };
+    if let Ok(sdk) = std::env::var("VULKAN_SDK") {
+        let candidate = Path::new(&sdk).join("Bin").join(exe);
+        if candidate.exists() {
+            return candidate;
+        }
+        let candidate = Path::new(&sdk).join("bin").join(exe);
+        if candidate.exists() {
+            return candidate;
+        }
+    }
+    PathBuf::from(exe)
+}

rust/crates/simv-vk/src/buffer.rs

@@ -0,0 +1,141 @@
+//! Буфер с памятью из аллокатора — перенос `simv::vk::Buffer`.
+//!
+//! Расхождение с C++-версией. Там `vk::Buffer` есть, но им не пользуется никто:
+//! `GridRenderer`, `GpuMesh` и глубинное вложение `Renderer` создают ресурсы напрямую
+//! вызовами VMA, а сама обёртка так и лежит в цели `simv_vk` мёртвым грузом. Здесь она
+//! задействована всеми тремя, потому что порт писался, когда потребители уже известны,
+//! а с gpu-allocator обёртка — самый короткий путь: она же и держит `Allocation`,
+//! который иначе пришлось бы освобождать руками в каждом `Drop`.
+
+use std::sync::{Arc, Mutex};
+
+use ash::vk;
+use gpu_allocator::vulkan::{Allocation, AllocationCreateDesc, AllocationScheme, Allocator};
+
+use crate::context::Context;
+use crate::error::{Ctx, Result, VkError};
+
+/// Где живёт память буфера.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum MemoryLocation {
+    /// Только для видеокарты: быстрая, недоступна процессору.
+    DeviceLocal,
+    /// Видима процессору, пишется последовательно (загрузка на видеокарту).
+    HostVisible,
+    /// Видима процессору, читается в произвольном порядке (чтение с видеокарты).
+    HostReadback,
+}
+
+impl From<MemoryLocation> for gpu_allocator::MemoryLocation {
+    fn from(value: MemoryLocation) -> Self {
+        match value {
+            MemoryLocation::DeviceLocal => gpu_allocator::MemoryLocation::GpuOnly,
+            MemoryLocation::HostVisible => gpu_allocator::MemoryLocation::CpuToGpu,
+            MemoryLocation::HostReadback => gpu_allocator::MemoryLocation::GpuToCpu,
+        }
+    }
+}
+
+pub struct Buffer {
+    device: ash::Device,
+    allocator: Arc<Mutex<Allocator>>,
+    handle: vk::Buffer,
+    /// `Option` ради `Drop`: память возвращается аллокатору по значению.
+    allocation: Option<Allocation>,
+    size: vk::DeviceSize,
+}
+
+impl Buffer {
+    pub fn new(
+        ctx: &Context,
+        name: &str,
+        size: vk::DeviceSize,
+        usage: vk::BufferUsageFlags,
+        location: MemoryLocation,
+    ) -> Result<Self> {
+        let device = ctx.device().clone();
+        let ci = vk::BufferCreateInfo::default()
+            .size(size)
+            .usage(usage)
+            .sharing_mode(vk::SharingMode::EXCLUSIVE);
+        let handle = unsafe { device.create_buffer(&ci, None) }.ctx("vkCreateBuffer")?;
+        let requirements = unsafe { device.get_buffer_memory_requirements(handle) };
+
+        let allocator = ctx.allocator().clone();
+        let allocation = {
+            let mut guard = allocator.lock().expect("аллокатор отравлен паникой");
+            guard.allocate(&AllocationCreateDesc {
+                name,
+                requirements,
+                location: location.into(),
+                linear: true,
+                allocation_scheme: AllocationScheme::GpuAllocatorManaged,
+            })
+        };
+        let allocation = match allocation {
+            Ok(a) => a,
+            Err(e) => {
+                unsafe { device.destroy_buffer(handle, None) };
+                return Err(VkError::Other(format!("gpu-allocator: {e}")));
+            }
+        };
+
+        unsafe { device.bind_buffer_memory(handle, allocation.memory(), allocation.offset()) }
+            .ctx("vkBindBufferMemory")?;
+
+        Ok(Self {
+            device,
+            allocator,
+            handle,
+            allocation: Some(allocation),
+            size,
+        })
+    }
+
+    pub fn handle(&self) -> vk::Buffer {
+        self.handle
+    }
+    pub fn size(&self) -> vk::DeviceSize {
+        self.size
+    }
+
+    /// Постоянно отображённая память, если она вообще видима процессору.
+    ///
+    /// В отличие от C++-версии здесь нет пары `Map`/`Unmap`: gpu-allocator держит
+    /// отображение всё время жизни выделения, а срез с временем жизни буфера не даёт
+    /// уронить указатель раньше самого буфера.
+    pub fn mapped(&mut self) -> Option<&mut [u8]> {
+        self.allocation.as_mut()?.mapped_slice_mut()
+    }
+
+    /// Записать байты по смещению. Возвращает ошибку, если память недоступна
+    /// процессору или запись не помещается.
+    pub fn write(&mut self, src: &[u8], offset: usize) -> Result<()> {
+        let size = self.size as usize;
+        let Some(dst) = self.mapped() else {
+            return Err(VkError::Other(String::from(
+                "запись в буфер, недоступный процессору",
+            )));
+        };
+        if offset + src.len() > size {
+            return Err(VkError::Other(format!(
+                "запись {} байт по смещению {offset} не помещается в буфер {size} байт",
+                src.len()
+            )));
+        }
+        dst[offset..offset + src.len()].copy_from_slice(src);
+        Ok(())
+    }
+}
+
+impl Drop for Buffer {
+    fn drop(&mut self) {
+        if let Some(allocation) = self.allocation.take() {
+            let _ = self
+                .allocator
+                .lock()
+                .map(|mut guard| guard.free(allocation));
+        }
+        unsafe { self.device.destroy_buffer(self.handle, None) };
+    }
+}

rust/crates/simv-vk/src/context.rs

@@ -0,0 +1,570 @@
+//! Инстанс, устройство, очереди, аллокатор и кэш конвейеров — перенос
+//! `simv::vk::Context`.
+//!
+//! Самый самостоятельный кусок порта. В C++ всё это строит vk-bootstrap: выбор
+//! физического устройства по требуемым возможностям, поиск семейств очередей,
+//! проверка наличия слоя валидации. Замены vk-bootstrap в экосистеме Rust нет, так что
+//! ниже примерно двести пятьдесят строк, которых в C++-версии просто не существует.
+
+use std::ffi::{c_char, c_void, CStr};
+use std::sync::{Arc, Mutex};
+
+use ash::vk;
+use gpu_allocator::vulkan::{Allocator, AllocatorCreateDesc};
+use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
+
+use crate::error::{Ctx, Result, VkError};
+
+/// Пожелания к контексту. Значения по умолчанию совпадают с C++-версией, включая
+/// включённую валидацию во всех конфигурациях сборки.
+pub struct ContextOptions {
+    pub enable_validation: bool,
+    pub enable_debug_utils: bool,
+    pub require_async_compute: bool,
+    pub require_async_transfer: bool,
+}
+
+impl Default for ContextOptions {
+    fn default() -> Self {
+        Self {
+            enable_validation: true,
+            enable_debug_utils: true,
+            require_async_compute: true,
+            require_async_transfer: true,
+        }
+    }
+}
+
+const VALIDATION_LAYER: &CStr = c"VK_LAYER_KHRONOS_validation";
+
+/// Vulkan 1.3: инстанс, поверхность, физическое и логическое устройство, очереди,
+/// аллокатор памяти и кэш конвейеров.
+///
+/// Владеет всем перечисленным и разрушает в обратном порядке в `Drop`. Всё, что
+/// клонирует `ash::Device` (а это делают `GpuMesh`, `MeshRenderer`, `GridRenderer`),
+/// обязано быть уничтожено раньше контекста: клон `Device` — это копия таблицы
+/// функций, а не владеющая ссылка, и пережить `destroy_device` он не может.
+pub struct Context {
+    device_name: String,
+
+    graphics_queue: vk::Queue,
+    compute_queue: vk::Queue,
+    transfer_queue: vk::Queue,
+    graphics_family: u32,
+    compute_family: u32,
+    transfer_family: u32,
+
+    pipeline_cache: vk::PipelineCache,
+    /// `Option` только ради `Drop`: аллокатор обязан умереть до устройства.
+    allocator: Option<Arc<Mutex<Allocator>>>,
+
+    swapchain_loader: ash::khr::swapchain::Device,
+    device: ash::Device,
+    physical_device: vk::PhysicalDevice,
+
+    surface: vk::SurfaceKHR,
+    surface_loader: ash::khr::surface::Instance,
+    debug: Option<(ash::ext::debug_utils::Instance, vk::DebugUtilsMessengerEXT)>,
+    instance: ash::Instance,
+    /// `Option` ради `Drop`: при динамической загрузке `Entry` держит саму
+    /// библиотеку Vulkan, поэтому уйти она обязана последней — иначе
+    /// `destroy_instance` вызовет указатель в уже выгруженной DLL.
+    entry: Option<ash::Entry>,
+}
+
+impl Context {
+    pub fn new(window: &simv_core::Window, opts: &ContextOptions) -> Result<Self> {
+        let entry = unsafe { ash::Entry::load() }?;
+
+        let display_handle = window.raw().display_handle()?.as_raw();
+        let window_handle = window.raw().window_handle()?.as_raw();
+
+        // ── Инстанс ──────────────────────────────────────────────────────────
+        let mut extensions: Vec<*const c_char> =
+            ash_window::enumerate_required_extensions(display_handle)
+                .ctx("ash_window::enumerate_required_extensions")?
+                .to_vec();
+        if opts.enable_debug_utils {
+            extensions.push(ash::ext::debug_utils::NAME.as_ptr());
+        }
+
+        // Проверка наличия слоя обязательна: vk-bootstrap её делал, а без неё машина
+        // без установленного SDK не запустила бы приложение вовсе.
+        let mut layers: Vec<*const c_char> = Vec::new();
+        if opts.enable_validation {
+            let available = unsafe { entry.enumerate_instance_layer_properties() }
+                .ctx("vkEnumerateInstanceLayerProperties")?;
+            let has_validation = available
+                .iter()
+                .any(|l| l.layer_name_as_c_str() == Ok(VALIDATION_LAYER));
+            if has_validation {
+                layers.push(VALIDATION_LAYER.as_ptr());
+            } else {
+                log::warn!(target: "vk", "слой валидации не установлен — иду без него");
+            }
+        }
+
+        let app_info = vk::ApplicationInfo::default()
+            .application_name(c"SimVulcan")
+            .engine_name(c"simv")
+            .api_version(vk::API_VERSION_1_3);
+        let instance_ci = vk::InstanceCreateInfo::default()
+            .application_info(&app_info)
+            .enabled_extension_names(&extensions)
+            .enabled_layer_names(&layers);
+        let instance =
+            unsafe { entry.create_instance(&instance_ci, None) }.ctx("vkCreateInstance")?;
+
+        // Любой ранний выход дальше обязан прибрать уже созданное: `Drop` собирается
+        // только на полностью построенном контексте. Отсюда явный разбор ошибки.
+        match Self::build(&entry, &instance, display_handle, window_handle, opts) {
+            Ok(mut ctx) => {
+                ctx.entry = Some(entry);
+                Ok(ctx)
+            }
+            Err(e) => {
+                unsafe { instance.destroy_instance(None) };
+                Err(e)
+            }
+        }
+    }
+
+    /// Всё, что строится поверх готового инстанса.
+    fn build(
+        entry: &ash::Entry,
+        instance: &ash::Instance,
+        display_handle: raw_window_handle::RawDisplayHandle,
+        window_handle: raw_window_handle::RawWindowHandle,
+        opts: &ContextOptions,
+    ) -> Result<Self> {
+        // ── Сообщения валидации ──────────────────────────────────────────────
+        let debug = if opts.enable_debug_utils {
+            let loader = ash::ext::debug_utils::Instance::new(entry, instance);
+            let ci = vk::DebugUtilsMessengerCreateInfoEXT::default()
+                .message_severity(
+                    vk::DebugUtilsMessageSeverityFlagsEXT::ERROR
+                        | vk::DebugUtilsMessageSeverityFlagsEXT::WARNING,
+                )
+                .message_type(
+                    vk::DebugUtilsMessageTypeFlagsEXT::GENERAL
+                        | vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION
+                        | vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE,
+                )
+                .pfn_user_callback(Some(debug_callback));
+            let messenger = unsafe { loader.create_debug_utils_messenger(&ci, None) }
+                .ctx("vkCreateDebugUtilsMessengerEXT")?;
+            Some((loader, messenger))
+        } else {
+            None
+        };
+
+        // ── Поверхность ──────────────────────────────────────────────────────
+        let surface_loader = ash::khr::surface::Instance::new(entry, instance);
+        let surface = unsafe {
+            ash_window::create_surface(entry, instance, display_handle, window_handle, None)
+        }
+        .ctx("vkCreate*SurfaceKHR")?;
+
+        // ── Физическое устройство ────────────────────────────────────────────
+        let chosen = select_physical_device(instance, &surface_loader, surface)?;
+        let device_name = chosen.name.clone();
+        let physical_device = chosen.handle;
+
+        // ── Логическое устройство ────────────────────────────────────────────
+        let mut families = vec![chosen.graphics_family];
+        for f in [chosen.compute_family, chosen.transfer_family]
+            .into_iter()
+            .flatten()
+        {
+            if !families.contains(&f) {
+                families.push(f);
+            }
+        }
+        let priority = [1.0f32];
+        let queue_cis: Vec<_> = families
+            .iter()
+            .map(|&family| {
+                vk::DeviceQueueCreateInfo::default()
+                    .queue_family_index(family)
+                    .queue_priorities(&priority)
+            })
+            .collect();
+
+        let device_extensions = [ash::khr::swapchain::NAME.as_ptr()];
+        // Ровно тот набор, который включает C++-версия (Context.cpp: feat10/12/13).
+        let mut features13 = vk::PhysicalDeviceVulkan13Features::default()
+            .synchronization2(true)
+            .dynamic_rendering(true);
+        let mut features12 = vk::PhysicalDeviceVulkan12Features::default()
+            .timeline_semaphore(true)
+            .descriptor_indexing(true)
+            .buffer_device_address(true)
+            .shader_subgroup_extended_types(true)
+            .scalar_block_layout(true)
+            .runtime_descriptor_array(true);
+        // fillModeNonSolid — без него не собрать каркасный конвейер.
+        let features10 = vk::PhysicalDeviceFeatures::default().fill_mode_non_solid(true);
+        let mut features2 = vk::PhysicalDeviceFeatures2::default()
+            .features(features10)
+            .push_next(&mut features13)
+            .push_next(&mut features12);
+
+        let device_ci = vk::DeviceCreateInfo::default()
+            .queue_create_infos(&queue_cis)
+            .enabled_extension_names(&device_extensions)
+            .push_next(&mut features2);
+
+        let device = unsafe { instance.create_device(physical_device, &device_ci, None) }
+            .ctx("vkCreateDevice")?;
+
+        // ── Очереди ──────────────────────────────────────────────────────────
+        let graphics_family = chosen.graphics_family;
+        let graphics_queue = unsafe { device.get_device_queue(graphics_family, 0) };
+
+        let (compute_family, compute_queue) = match chosen.compute_family {
+            Some(f) if opts.require_async_compute => (f, unsafe { device.get_device_queue(f, 0) }),
+            _ => {
+                log::warn!(target: "vk", "выделенной вычислительной очереди нет — беру графическую");
+                (graphics_family, graphics_queue)
+            }
+        };
+        let (transfer_family, transfer_queue) = match chosen.transfer_family {
+            Some(f) if opts.require_async_transfer => (f, unsafe { device.get_device_queue(f, 0) }),
+            _ => {
+                log::warn!(target: "vk", "выделенной очереди передачи нет — беру графическую");
+                (graphics_family, graphics_queue)
+            }
+        };
+
+        // ── Аллокатор ────────────────────────────────────────────────────────
+        let allocator = Allocator::new(&AllocatorCreateDesc {
+            instance: instance.clone(),
+            device: device.clone(),
+            physical_device,
+            debug_settings: Default::default(),
+            buffer_device_address: true,
+            allocation_sizes: Default::default(),
+        })
+        .map_err(|e| VkError::Other(format!("gpu-allocator: {e}")))?;
+
+        let swapchain_loader = ash::khr::swapchain::Device::new(instance, &device);
+        let pipeline_cache = create_pipeline_cache(&device);
+
+        log::info!(target: "vk", "контекст Vulkan готов: {device_name}");
+
+        Ok(Self {
+            device_name,
+            graphics_queue,
+            compute_queue,
+            transfer_queue,
+            graphics_family,
+            compute_family,
+            transfer_family,
+            pipeline_cache,
+            allocator: Some(Arc::new(Mutex::new(allocator))),
+            swapchain_loader,
+            device,
+            physical_device,
+            surface,
+            surface_loader,
+            debug,
+            instance: instance.clone(),
+            // Заполняет вызывающий: сюда `Entry` не передаётся, чтобы на пути ошибки
+            // инстанс уничтожался ровно один раз, а библиотека выгружалась после него.
+            entry: None,
+        })
+    }
+
+    pub fn device(&self) -> &ash::Device {
+        &self.device
+    }
+    pub fn instance(&self) -> &ash::Instance {
+        &self.instance
+    }
+    pub fn physical_device(&self) -> vk::PhysicalDevice {
+        self.physical_device
+    }
+    pub fn surface(&self) -> vk::SurfaceKHR {
+        self.surface
+    }
+    pub fn surface_loader(&self) -> &ash::khr::surface::Instance {
+        &self.surface_loader
+    }
+    pub fn swapchain_loader(&self) -> &ash::khr::swapchain::Device {
+        &self.swapchain_loader
+    }
+    pub fn allocator(&self) -> &Arc<Mutex<Allocator>> {
+        self.allocator.as_ref().expect("аллокатор уже уничтожен")
+    }
+    pub fn graphics_queue(&self) -> vk::Queue {
+        self.graphics_queue
+    }
+    pub fn compute_queue(&self) -> vk::Queue {
+        self.compute_queue
+    }
+    pub fn transfer_queue(&self) -> vk::Queue {
+        self.transfer_queue
+    }
+    pub fn graphics_family(&self) -> u32 {
+        self.graphics_family
+    }
+    pub fn compute_family(&self) -> u32 {
+        self.compute_family
+    }
+    pub fn transfer_family(&self) -> u32 {
+        self.transfer_family
+    }
+    pub fn pipeline_cache(&self) -> vk::PipelineCache {
+        self.pipeline_cache
+    }
+    pub fn device_name(&self) -> &str {
+        &self.device_name
+    }
+
+    pub fn wait_idle(&self) {
+        let _ = unsafe { self.device.device_wait_idle() };
+    }
+}
+
+impl Drop for Context {
+    fn drop(&mut self) {
+        unsafe {
+            let _ = self.device.device_wait_idle();
+
+            save_pipeline_cache(&self.device, self.pipeline_cache);
+            if self.pipeline_cache != vk::PipelineCache::null() {
+                self.device.destroy_pipeline_cache(self.pipeline_cache, None);
+            }
+            // Аллокатор обязан уйти до устройства, иначе он освободит память уже
+            // уничтоженного `VkDevice`.
+            drop(self.allocator.take());
+
+            self.device.destroy_device(None);
+            self.surface_loader.destroy_surface(self.surface, None);
+            if let Some((loader, messenger)) = self.debug.take() {
+                loader.destroy_debug_utils_messenger(messenger, None);
+            }
+            self.instance.destroy_instance(None);
+        }
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+//  Выбор физического устройства — то, что в C++ делает vkb::PhysicalDeviceSelector
+// ─────────────────────────────────────────────────────────────────────────────
+
+struct ChosenDevice {
+    handle: vk::PhysicalDevice,
+    name: String,
+    graphics_family: u32,
+    /// Выделенное семейство: COMPUTE без GRAPHICS. `None` — такого нет.
+    compute_family: Option<u32>,
+    /// Выделенное семейство: TRANSFER без GRAPHICS и COMPUTE.
+    transfer_family: Option<u32>,
+    score: u32,
+}
+
+fn select_physical_device(
+    instance: &ash::Instance,
+    surface_loader: &ash::khr::surface::Instance,
+    surface: vk::SurfaceKHR,
+) -> Result<ChosenDevice> {
+    let devices =
+        unsafe { instance.enumerate_physical_devices() }.ctx("vkEnumeratePhysicalDevices")?;
+
+    let mut best: Option<ChosenDevice> = None;
+    for handle in devices {
+        let Some(candidate) = inspect_device(instance, surface_loader, surface, handle) else {
+            continue;
+        };
+        if best.as_ref().is_none_or(|b| candidate.score > b.score) {
+            best = Some(candidate);
+        }
+    }
+    best.ok_or(VkError::NoSuitableDevice)
+}
+
+fn inspect_device(
+    instance: &ash::Instance,
+    surface_loader: &ash::khr::surface::Instance,
+    surface: vk::SurfaceKHR,
+    handle: vk::PhysicalDevice,
+) -> Option<ChosenDevice> {
+    let props = unsafe { instance.get_physical_device_properties(handle) };
+    let name = props
+        .device_name_as_c_str()
+        .map(|s| s.to_string_lossy().into_owned())
+        .unwrap_or_else(|_| String::from("устройство без имени"));
+
+    if props.api_version < vk::API_VERSION_1_3 {
+        log::debug!(target: "vk", "{name}: пропускаю, API ниже 1.3");
+        return None;
+    }
+
+    // Возможности: ровно тот набор, который требует C++-версия.
+    //
+    // Запрос обёрнут в блок не для красоты. `push_next` в ash берёт `&mut` на
+    // вложенную структуру и держит заимствование, пока жива голова цепочки, поэтому
+    // читать `f13`/`f12` при живом `f2` компилятор не даёт. В C++ pNext — сырой
+    // указатель, и там этот вопрос просто не возникает. Блок гасит заимствование:
+    // наружу выходят уже заполненные значения.
+    let (f13, f12, f10) = {
+        let mut f13 = vk::PhysicalDeviceVulkan13Features::default();
+        let mut f12 = vk::PhysicalDeviceVulkan12Features::default();
+        let mut f2 = vk::PhysicalDeviceFeatures2::default()
+            .push_next(&mut f13)
+            .push_next(&mut f12);
+        unsafe { instance.get_physical_device_features2(handle, &mut f2) };
+        let f10 = f2.features;
+        (f13, f12, f10)
+    };
+
+    let missing = [
+        ("synchronization2", f13.synchronization2 == vk::TRUE),
+        ("dynamicRendering", f13.dynamic_rendering == vk::TRUE),
+        ("timelineSemaphore", f12.timeline_semaphore == vk::TRUE),
+        ("descriptorIndexing", f12.descriptor_indexing == vk::TRUE),
+        ("bufferDeviceAddress", f12.buffer_device_address == vk::TRUE),
+        (
+            "shaderSubgroupExtendedTypes",
+            f12.shader_subgroup_extended_types == vk::TRUE,
+        ),
+        ("scalarBlockLayout", f12.scalar_block_layout == vk::TRUE),
+        (
+            "runtimeDescriptorArray",
+            f12.runtime_descriptor_array == vk::TRUE,
+        ),
+        ("fillModeNonSolid", f10.fill_mode_non_solid == vk::TRUE),
+    ]
+    .into_iter()
+    .filter_map(|(feature, ok)| (!ok).then_some(feature))
+    .collect::<Vec<_>>();
+    if !missing.is_empty() {
+        log::debug!(target: "vk", "{name}: пропускаю, нет возможностей: {}", missing.join(", "));
+        return None;
+    }
+
+    let extensions = unsafe { instance.enumerate_device_extension_properties(handle) }.ok()?;
+    let has_swapchain = extensions
+        .iter()
+        .any(|e| e.extension_name_as_c_str() == Ok(ash::khr::swapchain::NAME));
+    if !has_swapchain {
+        log::debug!(target: "vk", "{name}: пропускаю, нет VK_KHR_swapchain");
+        return None;
+    }
+
+    // Семейства очередей. Графическое обязано ещё и уметь показывать на поверхность:
+    // C++-версия полагалась на то, что vkb проверит это за неё.
+    let families = unsafe { instance.get_physical_device_queue_family_properties(handle) };
+    let mut graphics_family = None;
+    let mut compute_family = None;
+    let mut transfer_family = None;
+    for (index, family) in families.iter().enumerate() {
+        let i = index as u32;
+        let flags = family.queue_flags;
+        let graphics = flags.contains(vk::QueueFlags::GRAPHICS);
+        let compute = flags.contains(vk::QueueFlags::COMPUTE);
+        let transfer = flags.contains(vk::QueueFlags::TRANSFER);
+
+        if graphics_family.is_none() && graphics {
+            let presents =
+                unsafe { surface_loader.get_physical_device_surface_support(handle, i, surface) }
+                    .unwrap_or(false);
+            if presents {
+                graphics_family = Some(i);
+            }
+        }
+        if compute_family.is_none() && compute && !graphics {
+            compute_family = Some(i);
+        }
+        if transfer_family.is_none() && transfer && !graphics && !compute {
+            transfer_family = Some(i);
+        }
+    }
+    let graphics_family = graphics_family?;
+
+    let score = match props.device_type {
+        vk::PhysicalDeviceType::DISCRETE_GPU => 1000,
+        vk::PhysicalDeviceType::INTEGRATED_GPU => 100,
+        vk::PhysicalDeviceType::VIRTUAL_GPU => 10,
+        _ => 1,
+    };
+
+    Some(ChosenDevice {
+        handle,
+        name,
+        graphics_family,
+        compute_family,
+        transfer_family,
+        score,
+    })
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+//  Кэш конвейеров
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Файл кэша лежит рядом с исполняемым файлом, а не в текущем каталоге, как в
+/// C++-версии: запускать редактор из произвольного места теперь можно, и кэш при этом
+/// не рассыпается по диску.
+fn pipeline_cache_path() -> std::path::PathBuf {
+    std::env::current_exe()
+        .ok()
+        .and_then(|p| p.parent().map(|d| d.join("pipeline_cache.bin")))
+        .unwrap_or_else(|| std::path::PathBuf::from("pipeline_cache.bin"))
+}
+
+fn create_pipeline_cache(device: &ash::Device) -> vk::PipelineCache {
+    let blob = std::fs::read(pipeline_cache_path()).unwrap_or_default();
+    let ci = vk::PipelineCacheCreateInfo::default().initial_data(&blob);
+    match unsafe { device.create_pipeline_cache(&ci, None) } {
+        Ok(cache) => {
+            log::info!(target: "vk", "кэш конвейеров загружен: {} байт", blob.len());
+            cache
+        }
+        Err(e) => {
+            log::warn!(
+                target: "vk",
+                "кэш конвейеров не создан ({e:?}) — конвейеры будут пересобираться каждый запуск"
+            );
+            vk::PipelineCache::null()
+        }
+    }
+}
+
+fn save_pipeline_cache(device: &ash::Device, cache: vk::PipelineCache) {
+    if cache == vk::PipelineCache::null() {
+        return;
+    }
+    if let Ok(blob) = unsafe { device.get_pipeline_cache_data(cache) } {
+        if !blob.is_empty() {
+            let _ = std::fs::write(pipeline_cache_path(), &blob);
+        }
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+//  Сообщения слоя валидации
+// ─────────────────────────────────────────────────────────────────────────────
+
+unsafe extern "system" fn debug_callback(
+    severity: vk::DebugUtilsMessageSeverityFlagsEXT,
+    _types: vk::DebugUtilsMessageTypeFlagsEXT,
+    data: *const vk::DebugUtilsMessengerCallbackDataEXT<'_>,
+    _user: *mut c_void,
+) -> vk::Bool32 {
+    let message = unsafe {
+        data.as_ref()
+            .filter(|d| !d.p_message.is_null())
+            .map(|d| CStr::from_ptr(d.p_message).to_string_lossy())
+            .unwrap_or(std::borrow::Cow::Borrowed("сообщение без текста"))
+    };
+    if severity.contains(vk::DebugUtilsMessageSeverityFlagsEXT::ERROR) {
+        log::error!(target: "vk", "{message}");
+    } else if severity.contains(vk::DebugUtilsMessageSeverityFlagsEXT::WARNING) {
+        log::warn!(target: "vk", "{message}");
+    } else {
+        log::info!(target: "vk", "{message}");
+    }
+    vk::FALSE
+}

rust/crates/simv-vk/src/error.rs

@@ -0,0 +1,43 @@
+//! Ошибки Vulkan-слоя.
+//!
+//! C++-версия бросала `std::runtime_error` со строкой, собранной на месте. Здесь
+//! ошибка — значение: её нельзя не заметить, а `?` избавляет от той же ручной
+//! проверки `if (r != VK_SUCCESS)`, которой в `Renderer.cpp` посвящена отдельная
+//! функция `CheckVk`.
+
+use ash::vk;
+
+#[derive(Debug, thiserror::Error)]
+pub enum VkError {
+    #[error("не удалось загрузить библиотеку Vulkan (нет драйвера или загрузчика): {0}")]
+    Loading(#[from] ash::LoadingError),
+
+    #[error("{context} вернул ошибку: {source:?}")]
+    Api {
+        context: &'static str,
+        #[source]
+        source: vk::Result,
+    },
+
+    #[error("не найдено устройство Vulkan 1.3 с нужным набором возможностей")]
+    NoSuitableDevice,
+
+    #[error("не удалось получить дескриптор окна: {0}")]
+    WindowHandle(#[from] raw_window_handle::HandleError),
+
+    #[error("{0}")]
+    Other(String),
+}
+
+pub type Result<T> = std::result::Result<T, VkError>;
+
+/// Навесить на результат ash имя вызова — то же, что делал `CheckVk(r, where)`.
+pub(crate) trait Ctx<T> {
+    fn ctx(self, context: &'static str) -> Result<T>;
+}
+
+impl<T> Ctx<T> for std::result::Result<T, vk::Result> {
+    fn ctx(self, context: &'static str) -> Result<T> {
+        self.map_err(|source| VkError::Api { context, source })
+    }
+}

rust/crates/simv-vk/src/gpu_mesh.rs

@@ -0,0 +1,158 @@
+//! Меш на видеокарте — перенос `simv::vk::GpuMesh`.
+//!
+//! Загрузка через промежуточный буфер на очереди передачи, с ожиданием забора.
+//! Загрузки редки (открытие модели), так что блокирующая копия здесь уместна — но
+//! копировать этот приём в покадровые пути нельзя.
+//!
+//! В C++ у `GpuMesh` есть состояние «пустой» и метод `IsValid()`, а у `Renderer` —
+//! отдельный флаг `hasMesh`. Здесь оба исчезли: незагруженный меш выражается через
+//! `Option<GpuMesh>`, и забыть проверить его невозможно — компилятор не даст.
+
+use ash::vk;
+use simv_mesh::Mesh;
+
+use crate::buffer::{Buffer, MemoryLocation};
+use crate::context::Context;
+use crate::error::{Ctx, Result, VkError};
+
+pub struct GpuMesh {
+    vertex: Buffer,
+    index: Buffer,
+    vertex_count: u32,
+    index_count: u32,
+}
+
+impl GpuMesh {
+    pub fn upload(ctx: &Context, mesh: &Mesh) -> Result<Self> {
+        if mesh.is_empty() {
+            return Err(VkError::Other(String::from(
+                "выгрузка пустого меша на видеокарту",
+            )));
+        }
+        let vertex_count = mesh.positions.len() as u32;
+        let index_count = mesh.indices.len() as u32;
+
+        let vertex_bytes: &[u8] = bytemuck::cast_slice(&mesh.positions);
+        let index_bytes: &[u8] = bytemuck::cast_slice(&mesh.indices);
+
+        let vertex = Buffer::new(
+            ctx,
+            "mesh.vertices",
+            vertex_bytes.len() as vk::DeviceSize,
+            vk::BufferUsageFlags::TRANSFER_DST | vk::BufferUsageFlags::VERTEX_BUFFER,
+            MemoryLocation::DeviceLocal,
+        )?;
+        let index = Buffer::new(
+            ctx,
+            "mesh.indices",
+            index_bytes.len() as vk::DeviceSize,
+            vk::BufferUsageFlags::TRANSFER_DST | vk::BufferUsageFlags::INDEX_BUFFER,
+            MemoryLocation::DeviceLocal,
+        )?;
+
+        let mut vertex_stage = Buffer::new(
+            ctx,
+            "mesh.vertices.staging",
+            vertex_bytes.len() as vk::DeviceSize,
+            vk::BufferUsageFlags::TRANSFER_SRC,
+            MemoryLocation::HostVisible,
+        )?;
+        let mut index_stage = Buffer::new(
+            ctx,
+            "mesh.indices.staging",
+            index_bytes.len() as vk::DeviceSize,
+            vk::BufferUsageFlags::TRANSFER_SRC,
+            MemoryLocation::HostVisible,
+        )?;
+        vertex_stage.write(vertex_bytes, 0)?;
+        index_stage.write(index_bytes, 0)?;
+
+        one_shot_copy(
+            ctx,
+            &[
+                (
+                    vertex_stage.handle(),
+                    vertex.handle(),
+                    vertex_bytes.len() as vk::DeviceSize,
+                ),
+                (
+                    index_stage.handle(),
+                    index.handle(),
+                    index_bytes.len() as vk::DeviceSize,
+                ),
+            ],
+        )?;
+
+        Ok(Self {
+            vertex,
+            index,
+            vertex_count,
+            index_count,
+        })
+    }
+
+    pub fn vertex_buffer(&self) -> vk::Buffer {
+        self.vertex.handle()
+    }
+    pub fn index_buffer(&self) -> vk::Buffer {
+        self.index.handle()
+    }
+    pub fn vertex_count(&self) -> u32 {
+        self.vertex_count
+    }
+    pub fn index_count(&self) -> u32 {
+        self.index_count
+    }
+}
+
+/// Одноразовый командный буфер на очереди передачи: записать копии, отправить,
+/// дождаться забора, прибрать за собой.
+///
+/// C++-версия вызывала эту функцию по разу на буфер, то есть дважды отправляла работу
+/// и дважды ждала. Здесь копии собраны в одну отправку — при загрузке `plane.obj`
+/// это экономит одно полное ожидание забора.
+fn one_shot_copy(ctx: &Context, copies: &[(vk::Buffer, vk::Buffer, vk::DeviceSize)]) -> Result<()> {
+    let device = ctx.device();
+
+    let pool_ci = vk::CommandPoolCreateInfo::default()
+        .flags(vk::CommandPoolCreateFlags::TRANSIENT)
+        .queue_family_index(ctx.transfer_family());
+    let pool = unsafe { device.create_command_pool(&pool_ci, None) }
+        .ctx("vkCreateCommandPool(one-shot)")?;
+
+    // Дальше любой выход обязан прибрать пул, поэтому тело вынесено в замыкание.
+    let result = (|| -> Result<()> {
+        let alloc_ci = vk::CommandBufferAllocateInfo::default()
+            .command_pool(pool)
+            .level(vk::CommandBufferLevel::PRIMARY)
+            .command_buffer_count(1);
+        let cmd = unsafe { device.allocate_command_buffers(&alloc_ci) }
+            .ctx("vkAllocateCommandBuffers(one-shot)")?[0];
+
+        let begin = vk::CommandBufferBeginInfo::default()
+            .flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT);
+        unsafe { device.begin_command_buffer(cmd, &begin) }.ctx("vkBeginCommandBuffer")?;
+        for &(src, dst, size) in copies {
+            let region = [vk::BufferCopy::default().size(size)];
+            unsafe { device.cmd_copy_buffer(cmd, src, dst, &region) };
+        }
+        unsafe { device.end_command_buffer(cmd) }.ctx("vkEndCommandBuffer")?;
+
+        let fence = unsafe { device.create_fence(&vk::FenceCreateInfo::default(), None) }
+            .ctx("vkCreateFence(one-shot)")?;
+        let cmds = [cmd];
+        let submit = [vk::SubmitInfo::default().command_buffers(&cmds)];
+        let submitted = unsafe { device.queue_submit(ctx.transfer_queue(), &submit, fence) };
+        let waited = submitted
+            .ctx("vkQueueSubmit(one-shot)")
+            .and_then(|()| {
+                unsafe { device.wait_for_fences(&[fence], true, u64::MAX) }
+                    .ctx("vkWaitForFences(one-shot)")
+            });
+        unsafe { device.destroy_fence(fence, None) };
+        waited
+    })();
+
+    unsafe { device.destroy_command_pool(pool, None) };
+    result
+}

rust/crates/simv-vk/src/grid_renderer.rs

@@ -0,0 +1,257 @@
+//! Опорная сетка и оси — перенос `simv::vk::GridRenderer`.
+//!
+//! Геометрия строится один раз в буфер, видимый процессору: она статична и крошечная,
+//! так что промежуточная копия ради неё не нужна. Дескрипторных наборов нет — всё
+//! состояние умещается в одну push-константу.
+
+use ash::vk;
+use glam::{Mat4, Vec3};
+
+use crate::buffer::{Buffer, MemoryLocation};
+use crate::context::Context;
+use crate::error::{Ctx, Result};
+use crate::shader::{spirv, ShaderModule};
+
+#[repr(C)]
+#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
+struct GridVertex {
+    pos: Vec3,
+    color: Vec3,
+}
+
+/// Половина протяжённости сетки в клетках и размер клетки — как в C++-версии.
+const HALF_EXTENT_CELLS: i32 = 10;
+const CELL_SIZE: f32 = 1.0;
+
+pub struct GridRenderer {
+    device: ash::Device,
+    layout: vk::PipelineLayout,
+    pipeline: vk::Pipeline,
+    vertex_buffer: Buffer,
+    vertex_count: u32,
+    color_format: vk::Format,
+    depth_format: vk::Format,
+}
+
+impl GridRenderer {
+    pub fn new(ctx: &Context) -> Result<Self> {
+        let device = ctx.device().clone();
+
+        let ranges = [vk::PushConstantRange::default()
+            .stage_flags(vk::ShaderStageFlags::VERTEX)
+            .offset(0)
+            .size(std::mem::size_of::<Mat4>() as u32)];
+        let layout_ci = vk::PipelineLayoutCreateInfo::default().push_constant_ranges(&ranges);
+        let layout = unsafe { device.create_pipeline_layout(&layout_ci, None) }
+            .ctx("vkCreatePipelineLayout(grid)")?;
+
+        let vertices = build_geometry();
+        let bytes: &[u8] = bytemuck::cast_slice(&vertices);
+        let mut vertex_buffer = Buffer::new(
+            ctx,
+            "grid.vertices",
+            bytes.len() as vk::DeviceSize,
+            vk::BufferUsageFlags::VERTEX_BUFFER,
+            MemoryLocation::HostVisible,
+        )?;
+        vertex_buffer.write(bytes, 0)?;
+
+        Ok(Self {
+            device,
+            layout,
+            pipeline: vk::Pipeline::null(),
+            vertex_buffer,
+            vertex_count: vertices.len() as u32,
+            color_format: vk::Format::UNDEFINED,
+            depth_format: vk::Format::UNDEFINED,
+        })
+    }
+
+    /// Пересобрать конвейер, если форматы вложений сменились (пересоздание swapchain).
+    pub fn ensure_pipeline(
+        &mut self,
+        ctx: &Context,
+        color_format: vk::Format,
+        depth_format: vk::Format,
+    ) -> Result<()> {
+        if self.pipeline != vk::Pipeline::null()
+            && self.color_format == color_format
+            && self.depth_format == depth_format
+        {
+            return Ok(());
+        }
+        self.destroy_pipeline();
+        self.color_format = color_format;
+        self.depth_format = depth_format;
+        self.pipeline = self.build_pipeline(ctx)?;
+        Ok(())
+    }
+
+    fn build_pipeline(&self, ctx: &Context) -> Result<vk::Pipeline> {
+        // Модули живут до конца функции и уничтожаются на выходе, включая пути ошибок.
+        let vert = ShaderModule::new(&self.device, spirv::GRID_VERT)?;
+        let frag = ShaderModule::new(&self.device, spirv::GRID_FRAG)?;
+        let stages = [
+            vk::PipelineShaderStageCreateInfo::default()
+                .stage(vk::ShaderStageFlags::VERTEX)
+                .module(vert.handle())
+                .name(c"main"),
+            vk::PipelineShaderStageCreateInfo::default()
+                .stage(vk::ShaderStageFlags::FRAGMENT)
+                .module(frag.handle())
+                .name(c"main"),
+        ];
+
+        let bindings = [vk::VertexInputBindingDescription::default()
+            .binding(0)
+            .stride(std::mem::size_of::<GridVertex>() as u32)
+            .input_rate(vk::VertexInputRate::VERTEX)];
+        let attributes = [
+            vk::VertexInputAttributeDescription::default()
+                .location(0)
+                .binding(0)
+                .format(vk::Format::R32G32B32_SFLOAT)
+                .offset(std::mem::offset_of!(GridVertex, pos) as u32),
+            vk::VertexInputAttributeDescription::default()
+                .location(1)
+                .binding(0)
+                .format(vk::Format::R32G32B32_SFLOAT)
+                .offset(std::mem::offset_of!(GridVertex, color) as u32),
+        ];
+        let vertex_input = vk::PipelineVertexInputStateCreateInfo::default()
+            .vertex_binding_descriptions(&bindings)
+            .vertex_attribute_descriptions(&attributes);
+
+        let input_assembly = vk::PipelineInputAssemblyStateCreateInfo::default()
+            .topology(vk::PrimitiveTopology::LINE_LIST);
+        let viewport = vk::PipelineViewportStateCreateInfo::default()
+            .viewport_count(1)
+            .scissor_count(1);
+        let rasterization = vk::PipelineRasterizationStateCreateInfo::default()
+            // Для линейной топологии режим заливки не используется.
+            .polygon_mode(vk::PolygonMode::FILL)
+            .cull_mode(vk::CullModeFlags::NONE)
+            .line_width(1.0);
+        let multisample = vk::PipelineMultisampleStateCreateInfo::default()
+            .rasterization_samples(vk::SampleCountFlags::TYPE_1);
+        let depth_stencil = vk::PipelineDepthStencilStateCreateInfo::default()
+            .depth_test_enable(true)
+            .depth_write_enable(true)
+            .depth_compare_op(vk::CompareOp::LESS_OR_EQUAL)
+            .min_depth_bounds(0.0)
+            .max_depth_bounds(1.0);
+        let blend_attachments = [vk::PipelineColorBlendAttachmentState::default()
+            .color_write_mask(vk::ColorComponentFlags::RGBA)];
+        let color_blend =
+            vk::PipelineColorBlendStateCreateInfo::default().attachments(&blend_attachments);
+        let dynamic_states = [vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR];
+        let dynamic = vk::PipelineDynamicStateCreateInfo::default().dynamic_states(&dynamic_states);
+
+        let color_formats = [self.color_format];
+        let mut rendering = vk::PipelineRenderingCreateInfo::default()
+            .color_attachment_formats(&color_formats)
+            .depth_attachment_format(self.depth_format);
+
+        let create_info = [vk::GraphicsPipelineCreateInfo::default()
+            .stages(&stages)
+            .vertex_input_state(&vertex_input)
+            .input_assembly_state(&input_assembly)
+            .viewport_state(&viewport)
+            .rasterization_state(&rasterization)
+            .multisample_state(&multisample)
+            .depth_stencil_state(&depth_stencil)
+            .color_blend_state(&color_blend)
+            .dynamic_state(&dynamic)
+            .layout(self.layout)
+            .push_next(&mut rendering)];
+
+        let pipelines = unsafe {
+            self.device
+                .create_graphics_pipelines(ctx.pipeline_cache(), &create_info, None)
+        }
+        .map_err(|(_, e)| crate::error::VkError::Api {
+            context: "vkCreateGraphicsPipelines(grid)",
+            source: e,
+        })?;
+        Ok(pipelines[0])
+    }
+
+    pub fn draw(&self, cmd: vk::CommandBuffer, view_proj: &Mat4) {
+        if self.pipeline == vk::Pipeline::null() || self.vertex_count == 0 {
+            return;
+        }
+        unsafe {
+            self.device
+                .cmd_bind_pipeline(cmd, vk::PipelineBindPoint::GRAPHICS, self.pipeline);
+            self.device.cmd_push_constants(
+                cmd,
+                self.layout,
+                vk::ShaderStageFlags::VERTEX,
+                0,
+                bytemuck::bytes_of(view_proj),
+            );
+            self.device
+                .cmd_bind_vertex_buffers(cmd, 0, &[self.vertex_buffer.handle()], &[0]);
+            self.device.cmd_draw(cmd, self.vertex_count, 1, 0, 0);
+        }
+    }
+
+    fn destroy_pipeline(&mut self) {
+        if self.pipeline != vk::Pipeline::null() {
+            unsafe { self.device.destroy_pipeline(self.pipeline, None) };
+            self.pipeline = vk::Pipeline::null();
+        }
+    }
+}
+
+impl Drop for GridRenderer {
+    fn drop(&mut self) {
+        self.destroy_pipeline();
+        unsafe { self.device.destroy_pipeline_layout(self.layout, None) };
+    }
+}
+
+/// Три плоскости сетки через начало координат плюс цветные оси.
+fn build_geometry() -> Vec<GridVertex> {
+    const GRID: Vec3 = Vec3::new(0.30, 0.31, 0.35);
+    let n = HALF_EXTENT_CELLS;
+    let ext = n as f32 * CELL_SIZE;
+
+    let mut verts = Vec::with_capacity(((2 * n + 1) * 6 * 2 + 6) as usize);
+    let mut line = |a: Vec3, b: Vec3, color: Vec3| {
+        verts.push(GridVertex { pos: a, color });
+        verts.push(GridVertex { pos: b, color });
+    };
+
+    for i in -n..=n {
+        let t = i as f32 * CELL_SIZE;
+        // Плоскость XZ (y = 0)
+        line(Vec3::new(-ext, 0.0, t), Vec3::new(ext, 0.0, t), GRID);
+        line(Vec3::new(t, 0.0, -ext), Vec3::new(t, 0.0, ext), GRID);
+        // Плоскость XY (z = 0)
+        line(Vec3::new(-ext, t, 0.0), Vec3::new(ext, t, 0.0), GRID);
+        line(Vec3::new(t, -ext, 0.0), Vec3::new(t, ext, 0.0), GRID);
+        // Плоскость YZ (x = 0)
+        line(Vec3::new(0.0, -ext, t), Vec3::new(0.0, ext, t), GRID);
+        line(Vec3::new(0.0, t, -ext), Vec3::new(0.0, t, ext), GRID);
+    }
+
+    // Оси идут последними, чтобы перекрыть серые центральные линии.
+    line(
+        Vec3::new(-ext, 0.0, 0.0),
+        Vec3::new(ext, 0.0, 0.0),
+        Vec3::new(0.85, 0.25, 0.25), // X красная
+    );
+    line(
+        Vec3::new(0.0, -ext, 0.0),
+        Vec3::new(0.0, ext, 0.0),
+        Vec3::new(0.25, 0.80, 0.30), // Y зелёная
+    );
+    line(
+        Vec3::new(0.0, 0.0, -ext),
+        Vec3::new(0.0, 0.0, ext),
+        Vec3::new(0.30, 0.45, 0.90), // Z синяя
+    );
+
+    verts
+}

rust/crates/simv-vk/src/image.rs

@@ -0,0 +1,182 @@
+//! Изображение с представлением — перенос `simv::vk::Image`.
+//!
+//! Как и `buffer.rs`, в C++-версии лежит без применения: глубинное вложение
+//! `Renderer` создаёт там свои `VkImage`/`VkImageView` напрямую. Здесь на нём как раз
+//! и построено глубинное вложение — см. заметку в `buffer.rs`.
+
+use std::sync::{Arc, Mutex};
+
+use ash::vk;
+use gpu_allocator::vulkan::{Allocation, AllocationCreateDesc, AllocationScheme, Allocator};
+
+use crate::context::Context;
+use crate::error::{Ctx, Result, VkError};
+
+pub struct ImageDesc {
+    pub extent: vk::Extent3D,
+    pub format: vk::Format,
+    pub usage: vk::ImageUsageFlags,
+    pub image_type: vk::ImageType,
+    pub view_type: vk::ImageViewType,
+    pub aspect: vk::ImageAspectFlags,
+}
+
+impl Default for ImageDesc {
+    fn default() -> Self {
+        Self {
+            extent: vk::Extent3D {
+                width: 1,
+                height: 1,
+                depth: 1,
+            },
+            format: vk::Format::R8G8B8A8_UNORM,
+            usage: vk::ImageUsageFlags::SAMPLED,
+            image_type: vk::ImageType::TYPE_2D,
+            view_type: vk::ImageViewType::TYPE_2D,
+            aspect: vk::ImageAspectFlags::COLOR,
+        }
+    }
+}
+
+pub struct Image {
+    device: ash::Device,
+    allocator: Arc<Mutex<Allocator>>,
+    image: vk::Image,
+    view: vk::ImageView,
+    allocation: Option<Allocation>,
+    extent: vk::Extent3D,
+    format: vk::Format,
+    aspect: vk::ImageAspectFlags,
+    /// Текущая раскладка. Отслеживается здесь, чтобы `transition_to` не выставлял
+    /// барьер на переход в ту же раскладку — так же, как в C++-версии.
+    layout: vk::ImageLayout,
+}
+
+impl Image {
+    pub fn new(ctx: &Context, name: &str, desc: &ImageDesc) -> Result<Self> {
+        let device = ctx.device().clone();
+        let ci = vk::ImageCreateInfo::default()
+            .image_type(desc.image_type)
+            .format(desc.format)
+            .extent(desc.extent)
+            .mip_levels(1)
+            .array_layers(1)
+            .samples(vk::SampleCountFlags::TYPE_1)
+            .tiling(vk::ImageTiling::OPTIMAL)
+            .usage(desc.usage)
+            .sharing_mode(vk::SharingMode::EXCLUSIVE)
+            .initial_layout(vk::ImageLayout::UNDEFINED);
+        let image = unsafe { device.create_image(&ci, None) }.ctx("vkCreateImage")?;
+        let requirements = unsafe { device.get_image_memory_requirements(image) };
+
+        let allocator = ctx.allocator().clone();
+        let allocation = {
+            let mut guard = allocator.lock().expect("аллокатор отравлен паникой");
+            guard.allocate(&AllocationCreateDesc {
+                name,
+                requirements,
+                location: gpu_allocator::MemoryLocation::GpuOnly,
+                linear: false,
+                allocation_scheme: AllocationScheme::GpuAllocatorManaged,
+            })
+        };
+        let allocation = match allocation {
+            Ok(a) => a,
+            Err(e) => {
+                unsafe { device.destroy_image(image, None) };
+                return Err(VkError::Other(format!("gpu-allocator: {e}")));
+            }
+        };
+        unsafe { device.bind_image_memory(image, allocation.memory(), allocation.offset()) }
+            .ctx("vkBindImageMemory")?;
+
+        let view_ci = vk::ImageViewCreateInfo::default()
+            .image(image)
+            .view_type(desc.view_type)
+            .format(desc.format)
+            .subresource_range(vk::ImageSubresourceRange {
+                aspect_mask: desc.aspect,
+                base_mip_level: 0,
+                level_count: 1,
+                base_array_layer: 0,
+                layer_count: 1,
+            });
+        let view = unsafe { device.create_image_view(&view_ci, None) }.ctx("vkCreateImageView")?;
+
+        Ok(Self {
+            device,
+            allocator,
+            image,
+            view,
+            allocation: Some(allocation),
+            extent: desc.extent,
+            format: desc.format,
+            aspect: desc.aspect,
+            layout: vk::ImageLayout::UNDEFINED,
+        })
+    }
+
+    pub fn image(&self) -> vk::Image {
+        self.image
+    }
+    pub fn view(&self) -> vk::ImageView {
+        self.view
+    }
+    pub fn extent(&self) -> vk::Extent3D {
+        self.extent
+    }
+    pub fn format(&self) -> vk::Format {
+        self.format
+    }
+    pub fn layout(&self) -> vk::ImageLayout {
+        self.layout
+    }
+
+    /// Барьер перехода раскладки на sync2. Повторный переход в ту же раскладку —
+    /// не операция.
+    pub fn transition_to(
+        &mut self,
+        cmd: vk::CommandBuffer,
+        new_layout: vk::ImageLayout,
+        src_stage: vk::PipelineStageFlags2,
+        src_access: vk::AccessFlags2,
+        dst_stage: vk::PipelineStageFlags2,
+        dst_access: vk::AccessFlags2,
+    ) {
+        if new_layout == self.layout {
+            return;
+        }
+        let barrier = vk::ImageMemoryBarrier2::default()
+            .src_stage_mask(src_stage)
+            .src_access_mask(src_access)
+            .dst_stage_mask(dst_stage)
+            .dst_access_mask(dst_access)
+            .old_layout(self.layout)
+            .new_layout(new_layout)
+            .image(self.image)
+            .subresource_range(vk::ImageSubresourceRange {
+                aspect_mask: self.aspect,
+                base_mip_level: 0,
+                level_count: 1,
+                base_array_layer: 0,
+                layer_count: 1,
+            });
+        let barriers = [barrier];
+        let dependency = vk::DependencyInfo::default().image_memory_barriers(&barriers);
+        unsafe { self.device.cmd_pipeline_barrier2(cmd, &dependency) };
+        self.layout = new_layout;
+    }
+}
+
+impl Drop for Image {
+    fn drop(&mut self) {
+        unsafe { self.device.destroy_image_view(self.view, None) };
+        if let Some(allocation) = self.allocation.take() {
+            let _ = self
+                .allocator
+                .lock()
+                .map(|mut guard| guard.free(allocation));
+        }
+        unsafe { self.device.destroy_image(self.image, None) };
+    }
+}

rust/crates/simv-vk/src/lib.rs

@@ -0,0 +1,26 @@
+//! Весь Vulkan редактора — соответствует цели `simv_vk`.
+//!
+//! Единственный крейт с `ash` в зависимостях. В C++ это правило («весь Vulkan живёт в
+//! `src/vk/`») держится на дисциплине и комментарии в CLAUDE.md; здесь его проверяет
+//! компоновщик зависимостей: у `simv-mesh` и `simv-editor` `ash` просто нет.
+//!
+//! Публичный интерфейс `Renderer` не содержит типов Vulkan — как и в C++-версии, где
+//! ради этого заведён pImpl. В Rust того же добиваются приватные поля модуля, так что
+//! `struct Renderer::Impl` и вся возня с `unique_ptr` не понадобились.
+
+pub mod buffer;
+pub mod context;
+pub mod error;
+pub mod gpu_mesh;
+pub mod grid_renderer;
+pub mod image;
+pub mod mesh_renderer;
+pub mod render_mode;
+pub mod renderer;
+pub mod shader;
+pub mod swapchain;
+
+pub use context::{Context, ContextOptions};
+pub use error::{Result, VkError};
+pub use render_mode::RenderMode;
+pub use renderer::{FrameState, Renderer};

rust/crates/simv-vk/src/mesh_renderer.rs

@@ -0,0 +1,238 @@
+//! Конвейеры модели — перенос `simv::vk::MeshRenderer`.
+//!
+//! Два конвейера на один макет: заливка и `POLYGON_MODE_LINE` для каркаса. У линейного
+//! включено небольшое смещение глубины, чтобы каркас лёг поверх заливки, а не спорил
+//! с ней за z. Отсечение выключено — у загруженных моделей обход граней вперемешку.
+//!
+//! ВАЖНО: `MeshPushConstants` обязан байт в байт совпадать с блоком `push_constant`
+//! в `shaders/editor/mesh.vert` и `mesh.frag`. Поле `color.a` — это ФЛАГ (1 — плоская
+//! заливка, 0 — постоянный цвет каркаса), а не прозрачность. Меняете здесь — меняйте
+//! и в шейдере.
+
+use ash::vk;
+use glam::{Mat4, Vec4};
+
+use crate::context::Context;
+use crate::error::{Ctx, Result, VkError};
+use crate::gpu_mesh::GpuMesh;
+use crate::render_mode::RenderMode;
+use crate::shader::{spirv, ShaderModule};
+
+#[repr(C)]
+#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
+struct MeshPushConstants {
+    mvp: Mat4,
+    color: Vec4,
+}
+
+/// `color.a`: 1 — плоская заливка, 0 — постоянный цвет.
+const SOLID: Vec4 = Vec4::new(0.72, 0.74, 0.78, 1.0);
+const WIRE: Vec4 = Vec4::new(0.78, 0.82, 0.88, 0.0);
+const OVERLAY: Vec4 = Vec4::new(0.06, 0.07, 0.09, 0.0);
+
+pub struct MeshRenderer {
+    device: ash::Device,
+    layout: vk::PipelineLayout,
+    fill: vk::Pipeline,
+    line: vk::Pipeline,
+    color_format: vk::Format,
+    depth_format: vk::Format,
+}
+
+impl MeshRenderer {
+    pub fn new(ctx: &Context) -> Result<Self> {
+        let device = ctx.device().clone();
+        let ranges = [vk::PushConstantRange::default()
+            .stage_flags(vk::ShaderStageFlags::VERTEX | vk::ShaderStageFlags::FRAGMENT)
+            .offset(0)
+            .size(std::mem::size_of::<MeshPushConstants>() as u32)];
+        let layout_ci = vk::PipelineLayoutCreateInfo::default().push_constant_ranges(&ranges);
+        let layout = unsafe { device.create_pipeline_layout(&layout_ci, None) }
+            .ctx("vkCreatePipelineLayout(mesh)")?;
+
+        Ok(Self {
+            device,
+            layout,
+            fill: vk::Pipeline::null(),
+            line: vk::Pipeline::null(),
+            color_format: vk::Format::UNDEFINED,
+            depth_format: vk::Format::UNDEFINED,
+        })
+    }
+
+    pub fn ensure_pipelines(
+        &mut self,
+        ctx: &Context,
+        color_format: vk::Format,
+        depth_format: vk::Format,
+    ) -> Result<()> {
+        if self.fill != vk::Pipeline::null()
+            && self.color_format == color_format
+            && self.depth_format == depth_format
+        {
+            return Ok(());
+        }
+        self.destroy_pipelines();
+        self.color_format = color_format;
+        self.depth_format = depth_format;
+        self.fill = self.build_pipeline(ctx, vk::PolygonMode::FILL, false)?;
+        self.line = self.build_pipeline(ctx, vk::PolygonMode::LINE, true)?;
+        Ok(())
+    }
+
+    fn build_pipeline(
+        &self,
+        ctx: &Context,
+        polygon_mode: vk::PolygonMode,
+        depth_bias: bool,
+    ) -> Result<vk::Pipeline> {
+        let vert = ShaderModule::new(&self.device, spirv::MESH_VERT)?;
+        let frag = ShaderModule::new(&self.device, spirv::MESH_FRAG)?;
+        let stages = [
+            vk::PipelineShaderStageCreateInfo::default()
+                .stage(vk::ShaderStageFlags::VERTEX)
+                .module(vert.handle())
+                .name(c"main"),
+            vk::PipelineShaderStageCreateInfo::default()
+                .stage(vk::ShaderStageFlags::FRAGMENT)
+                .module(frag.handle())
+                .name(c"main"),
+        ];
+
+        // Поток вершин — плотный float3: `mesh.frag` восстанавливает нормаль грани из
+        // экранных производных, так что нормали передавать не нужно.
+        let bindings = [vk::VertexInputBindingDescription::default()
+            .binding(0)
+            .stride(std::mem::size_of::<f32>() as u32 * 3)
+            .input_rate(vk::VertexInputRate::VERTEX)];
+        let attributes = [vk::VertexInputAttributeDescription::default()
+            .location(0)
+            .binding(0)
+            .format(vk::Format::R32G32B32_SFLOAT)
+            .offset(0)];
+        let vertex_input = vk::PipelineVertexInputStateCreateInfo::default()
+            .vertex_binding_descriptions(&bindings)
+            .vertex_attribute_descriptions(&attributes);
+
+        let input_assembly = vk::PipelineInputAssemblyStateCreateInfo::default()
+            .topology(vk::PrimitiveTopology::TRIANGLE_LIST);
+        let viewport = vk::PipelineViewportStateCreateInfo::default()
+            .viewport_count(1)
+            .scissor_count(1);
+
+        let mut rasterization = vk::PipelineRasterizationStateCreateInfo::default()
+            .polygon_mode(polygon_mode)
+            // У загруженных моделей обход граней бывает вперемешку.
+            .cull_mode(vk::CullModeFlags::NONE)
+            .front_face(vk::FrontFace::COUNTER_CLOCKWISE)
+            .line_width(1.0);
+        if depth_bias {
+            // Подвинуть каркас к камере, чтобы он лёг поверх заливки.
+            rasterization = rasterization
+                .depth_bias_enable(true)
+                .depth_bias_constant_factor(-1.0)
+                .depth_bias_slope_factor(-1.0);
+        }
+
+        let multisample = vk::PipelineMultisampleStateCreateInfo::default()
+            .rasterization_samples(vk::SampleCountFlags::TYPE_1);
+        let depth_stencil = vk::PipelineDepthStencilStateCreateInfo::default()
+            .depth_test_enable(true)
+            .depth_write_enable(true)
+            .depth_compare_op(vk::CompareOp::LESS_OR_EQUAL)
+            .min_depth_bounds(0.0)
+            .max_depth_bounds(1.0);
+        let blend_attachments = [vk::PipelineColorBlendAttachmentState::default()
+            .color_write_mask(vk::ColorComponentFlags::RGBA)];
+        let color_blend =
+            vk::PipelineColorBlendStateCreateInfo::default().attachments(&blend_attachments);
+        let dynamic_states = [vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR];
+        let dynamic = vk::PipelineDynamicStateCreateInfo::default().dynamic_states(&dynamic_states);
+
+        let color_formats = [self.color_format];
+        let mut rendering = vk::PipelineRenderingCreateInfo::default()
+            .color_attachment_formats(&color_formats)
+            .depth_attachment_format(self.depth_format);
+
+        let create_info = [vk::GraphicsPipelineCreateInfo::default()
+            .stages(&stages)
+            .vertex_input_state(&vertex_input)
+            .input_assembly_state(&input_assembly)
+            .viewport_state(&viewport)
+            .rasterization_state(&rasterization)
+            .multisample_state(&multisample)
+            .depth_stencil_state(&depth_stencil)
+            .color_blend_state(&color_blend)
+            .dynamic_state(&dynamic)
+            .layout(self.layout)
+            .push_next(&mut rendering)];
+
+        let pipelines = unsafe {
+            self.device
+                .create_graphics_pipelines(ctx.pipeline_cache(), &create_info, None)
+        }
+        .map_err(|(_, e)| VkError::Api {
+            context: "vkCreateGraphicsPipelines(mesh)",
+            source: e,
+        })?;
+        Ok(pipelines[0])
+    }
+
+    pub fn draw(&self, cmd: vk::CommandBuffer, mesh: &GpuMesh, mvp: &Mat4, mode: RenderMode) {
+        if self.fill == vk::Pipeline::null() || self.line == vk::Pipeline::null() {
+            return;
+        }
+        unsafe {
+            self.device
+                .cmd_bind_vertex_buffers(cmd, 0, &[mesh.vertex_buffer()], &[0]);
+            self.device
+                .cmd_bind_index_buffer(cmd, mesh.index_buffer(), 0, vk::IndexType::UINT32);
+        }
+
+        let draw_with = |pipeline: vk::Pipeline, color: Vec4| {
+            let push = MeshPushConstants { mvp: *mvp, color };
+            unsafe {
+                self.device
+                    .cmd_bind_pipeline(cmd, vk::PipelineBindPoint::GRAPHICS, pipeline);
+                self.device.cmd_push_constants(
+                    cmd,
+                    self.layout,
+                    vk::ShaderStageFlags::VERTEX | vk::ShaderStageFlags::FRAGMENT,
+                    0,
+                    bytemuck::bytes_of(&push),
+                );
+                self.device
+                    .cmd_draw_indexed(cmd, mesh.index_count(), 1, 0, 0, 0);
+            }
+        };
+
+        match mode {
+            RenderMode::Solid => draw_with(self.fill, SOLID),
+            RenderMode::Wireframe => draw_with(self.line, WIRE),
+            RenderMode::SolidWire => {
+                draw_with(self.fill, SOLID);
+                draw_with(self.line, OVERLAY);
+            }
+        }
+    }
+
+    fn destroy_pipelines(&mut self) {
+        unsafe {
+            if self.fill != vk::Pipeline::null() {
+                self.device.destroy_pipeline(self.fill, None);
+                self.fill = vk::Pipeline::null();
+            }
+            if self.line != vk::Pipeline::null() {
+                self.device.destroy_pipeline(self.line, None);
+                self.line = vk::Pipeline::null();
+            }
+        }
+    }
+}
+
+impl Drop for MeshRenderer {
+    fn drop(&mut self) {
+        self.destroy_pipelines();
+        unsafe { self.device.destroy_pipeline_layout(self.layout, None) };
+    }
+}

rust/crates/simv-vk/src/render_mode.rs

@@ -0,0 +1,13 @@
+//! Режим отображения модели — перенос `simv::vk::RenderMode`.
+
+/// Как рисуется загруженная модель во вьюпорте.
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
+pub enum RenderMode {
+    /// Залитые треугольники с плоской заливкой по нормали грани.
+    #[default]
+    Solid,
+    /// Только рёбра треугольников.
+    Wireframe,
+    /// Заливка с наложенным поверх каркасом.
+    SolidWire,
+}

rust/crates/simv-vk/src/renderer.rs

@@ -0,0 +1,626 @@
+//! Кадр целиком — перенос `simv::vk::Renderer`.
+//!
+//! Владеет всем стеком показа: контекстом, цепочкой показа, глубинным вложением,
+//! покадровыми командными буферами и синхронизацией, бэкендом egui и обоими
+//! рендерерами сцены. В публичном интерфейсе нет ни одного типа Vulkan — ровно та же
+//! цель, ради которой в C++ заведён pImpl, но здесь её решают приватные поля модуля,
+//! так что `struct Renderer::Impl` и `unique_ptr` не понадобились.
+//!
+//! Расхождение с C++-версией: там замыкание интерфейса хранится полем
+//! (`SetUiCallback`), здесь оно передаётся параметром в [`Renderer::draw_frame`].
+//! Причина не стилистическая. Замыкание в C++ захватывает по ссылке разом камеру,
+//! панели и сам рендерер; в Rust хранить такой `FnMut` внутри объекта, который это же
+//! замыкание и вызывает, значит одолжить рендерер дважды — компилятор не пропустит.
+//! Параметр развязывает время жизни и ничего не стоит.
+
+use ash::vk;
+use egui_ash_renderer::{DynamicRendering, Options};
+use glam::Mat4;
+use simv_mesh::Mesh;
+
+use crate::context::{Context, ContextOptions};
+use crate::error::{Ctx, Result, VkError};
+use crate::gpu_mesh::GpuMesh;
+use crate::grid_renderer::GridRenderer;
+use crate::image::{Image, ImageDesc};
+use crate::mesh_renderer::MeshRenderer;
+use crate::render_mode::RenderMode;
+use crate::swapchain::Swapchain;
+
+/// Бэкенд egui поверх нашего же аллокатора: обёртка `GpuAllocator` — это
+/// `Arc<Mutex<gpu_allocator::vulkan::Allocator>>`, тот самый, что раздаёт память
+/// буферам и изображениям сцены. Одна куча на всё приложение.
+type EguiRenderer = egui_ash_renderer::Renderer<egui_ash_renderer::allocator::GpuAllocator>;
+
+const FRAMES_IN_FLIGHT: usize = 2;
+const DEPTH_FORMAT: vk::Format = vk::Format::D32_SFLOAT;
+const CLEAR_COLOR: [f32; 4] = [0.05, 0.06, 0.08, 1.0];
+
+struct FrameSlot {
+    cmd_pool: vk::CommandPool,
+    cmd: vk::CommandBuffer,
+    image_available: vk::Semaphore,
+    in_flight: vk::Fence,
+    /// Текстуры egui, которые перестали быть нужны на кадре, использовавшем этот слот.
+    /// Освобождаются, когда забор слота снова сработает, — то есть когда видеокарта
+    /// точно закончила с тем кадром.
+    textures_to_free: Vec<egui::TextureId>,
+}
+
+pub struct Renderer {
+    // Поля объявлены в порядке уничтожения: всё, что держит клон `ash::Device` или
+    // ссылку на аллокатор, обязано уйти раньше контекста, а контекст — последним.
+    egui_renderer: EguiRenderer,
+    egui_state: egui_winit::State,
+    egui_ctx: egui::Context,
+    egui_pool: vk::CommandPool,
+
+    gpu_mesh: Option<GpuMesh>,
+    mesh_renderer: MeshRenderer,
+    grid_renderer: GridRenderer,
+
+    depth: Image,
+    frames: Vec<FrameSlot>,
+    render_finished: Vec<vk::Semaphore>,
+    cursor: usize,
+
+    swapchain: Swapchain,
+    context: Context,
+
+    /// Матрица модели: загруженная сетка переносится в начало координат.
+    model: Mat4,
+}
+
+/// Что интерфейс сообщает сцене на этом кадре.
+///
+/// В C++ то же состояние попадало в рендерер сеттерами (`SetViewProj`,
+/// `SetRenderMode`, `SetGridVisible`), которые UI-колбэк вызывал прямо из
+/// `DrawFrame`. Здесь колбэк вызывается из метода рендерера, поэтому трогать
+/// рендерер оттуда нельзя — он уже одолжен. Состояние вместо этого возвращается
+/// из замыкания и применяется к тому же кадру, без отставания на кадр.
+pub struct FrameState {
+    pub view_proj: Mat4,
+    pub render_mode: RenderMode,
+    pub grid_visible: bool,
+}
+
+impl Renderer {
+    pub fn new(window: &simv_core::Window) -> Result<Self> {
+        let context = Context::new(
+            window,
+            &ContextOptions {
+                // В редакторе нет вычислительной работы.
+                require_async_compute: false,
+                ..Default::default()
+            },
+        )?;
+        let swapchain = Swapchain::new(&context, window, true)?;
+
+        let (frames, render_finished) = create_frame_state(&context, swapchain.frames().len())?;
+        let depth = create_depth(&context, swapchain.extent())?;
+
+        let egui_ctx = egui::Context::default();
+        let egui_state = egui_winit::State::new(
+            egui_ctx.clone(),
+            egui::ViewportId::ROOT,
+            window.raw(),
+            Some(window.raw().scale_factor() as f32),
+            None,
+            None,
+        );
+        let egui_pool = {
+            let ci = vk::CommandPoolCreateInfo::default()
+                .flags(vk::CommandPoolCreateFlags::TRANSIENT)
+                .queue_family_index(context.graphics_family());
+            unsafe { context.device().create_command_pool(&ci, None) }
+                .ctx("vkCreateCommandPool(egui)")?
+        };
+        let egui_renderer = EguiRenderer::with_gpu_allocator(
+            context.allocator().clone(),
+            context.device().clone(),
+            egui_ash_renderer::RenderMode::DynamicRendering(dynamic_rendering(&swapchain)),
+            egui_options(),
+        )
+        .map_err(|e| VkError::Other(format!("egui_ash_renderer: {e}")))?;
+
+        let mut mesh_renderer = MeshRenderer::new(&context)?;
+        let mut grid_renderer = GridRenderer::new(&context)?;
+        mesh_renderer.ensure_pipelines(&context, swapchain.color_format(), DEPTH_FORMAT)?;
+        grid_renderer.ensure_pipeline(&context, swapchain.color_format(), DEPTH_FORMAT)?;
+
+        Ok(Self {
+            egui_renderer,
+            egui_state,
+            egui_ctx,
+            egui_pool,
+            gpu_mesh: None,
+            mesh_renderer,
+            grid_renderer,
+            depth,
+            frames,
+            render_finished,
+            cursor: 0,
+            swapchain,
+            context,
+            model: Mat4::IDENTITY,
+        })
+    }
+
+    /// Отношение сторон кадрового буфера — для матрицы проекции.
+    pub fn aspect_ratio(&self) -> f32 {
+        let extent = self.swapchain.extent();
+        if extent.height == 0 {
+            return 1.0;
+        }
+        extent.width as f32 / extent.height as f32
+    }
+
+    /// Скормить событие окна интерфейсу. Возвращает `true`, если egui его забрал себе
+    /// и сцене оно не предназначено.
+    pub fn on_window_event(
+        &mut self,
+        window: &simv_core::Window,
+        event: &winit::event::WindowEvent,
+    ) -> bool {
+        self.egui_state
+            .on_window_event(window.raw(), event)
+            .consumed
+    }
+
+    /// Выгрузить меш на видеокарту и заново отцентрировать модель на начале координат.
+    ///
+    /// Ожидание простоя устройства здесь допустимо: загрузки редки. В покадровые пути
+    /// этот приём переносить нельзя.
+    pub fn set_mesh_cpu(&mut self, mesh: &Mesh) -> Result<()> {
+        if mesh.is_empty() {
+            return Ok(());
+        }
+        self.context.wait_idle();
+        self.gpu_mesh = Some(GpuMesh::upload(&self.context, mesh)?);
+        let center = 0.5 * (mesh.bbox_min + mesh.bbox_max);
+        self.model = Mat4::from_translation(-center);
+        Ok(())
+    }
+
+    pub fn clear_mesh(&mut self) {
+        self.context.wait_idle();
+        self.gpu_mesh = None;
+        self.model = Mat4::IDENTITY;
+    }
+
+    pub fn wait_idle(&self) {
+        self.context.wait_idle();
+    }
+
+    /// Нарисовать кадр: интерфейс, сетка, модель — и показать.
+    ///
+    /// Замыкание вызывается между сбором ввода и тесселяцией, то есть ровно там же,
+    /// где C++-версия зовёт `uiCallback` между `ImGui::NewFrame` и `ImGui::Render`.
+    pub fn draw_frame(
+        &mut self,
+        window: &simv_core::Window,
+        mut ui: impl FnMut(&egui::Context) -> FrameState,
+    ) -> Result<()> {
+        let (fbw, fbh) = window.framebuffer_size();
+        if fbw == 0 || fbh == 0 {
+            return Ok(()); // свёрнуто — рисовать некуда
+        }
+
+        let slot = self.cursor % FRAMES_IN_FLIGHT;
+        let device = self.context.device().clone();
+
+        let in_flight = self.frames[slot].in_flight;
+        unsafe { device.wait_for_fences(&[in_flight], true, u64::MAX) }.ctx("vkWaitForFences")?;
+
+        // Забор сработал — значит кадр, занимавший этот слот, отсчитан, и его текстуры
+        // можно отдавать.
+        for id in std::mem::take(&mut self.frames[slot].textures_to_free) {
+            self.egui_renderer
+                .free_texture(id)
+                .map_err(|e| VkError::Other(format!("egui free_texture: {e}")))?;
+        }
+
+        let acquired = unsafe {
+            self.context.swapchain_loader().acquire_next_image(
+                self.swapchain.handle(),
+                u64::MAX,
+                self.frames[slot].image_available,
+                vk::Fence::null(),
+            )
+        };
+        let image_index = match acquired {
+            Ok((index, _suboptimal)) => index as usize,
+            Err(vk::Result::ERROR_OUT_OF_DATE_KHR) => {
+                self.recreate_swap_dependent(window)?;
+                return Ok(());
+            }
+            Err(e) => return Err(VkError::Api { context: "vkAcquireNextImageKHR", source: e }),
+        };
+
+        // ── Кадр egui: панели заполняются переданным замыканием ──────────────
+        let raw_input = self.egui_state.take_egui_input(window.raw());
+        // egui может прогнать интерфейс не один раз за кадр (например, если виджет
+        // попросил пересчёт), поэтому берётся последнее состояние.
+        let mut frame_state = None;
+        let mut output = self.egui_ctx.run_ui(raw_input, |u| {
+            let ctx = u.ctx().clone();
+            frame_state = Some(ui(&ctx));
+        });
+        let frame_state = frame_state.expect("замыкание интерфейса не вернуло состояние кадра");
+        self.egui_state
+            .handle_platform_output(window.raw(), output.platform_output);
+        let primitives = self
+            .egui_ctx
+            .tessellate(output.shapes, output.pixels_per_point);
+
+        // egui 0.36 отдаёт на текстуру список правок, а не одну: атлас шрифта может
+        // дорасти несколькими кусками за кадр.
+        for (&id, deltas) in &output.textures_delta.set {
+            for delta in deltas {
+                self.egui_renderer
+                    .set_texture(
+                        self.context.graphics_queue(),
+                        self.egui_pool,
+                        id,
+                        delta,
+                    )
+                    .map_err(|e| VkError::Other(format!("egui set_texture: {e}")))?;
+            }
+        }
+        // Освобождение откладывается на два кадра: сейчас эти текстуры ещё попадут в
+        // командный буфер, который только предстоит отправить.
+        self.frames[slot]
+            .textures_to_free
+            .extend(output.textures_delta.free.iter().copied());
+        // У `TexturesDelta` есть `Drop`, который в отладочной сборке падает, если
+        // правки уронили не применив. Разобрали — говорим об этом явно.
+        output.textures_delta.clear();
+
+        // ── Запись команд ────────────────────────────────────────────────────
+        let cmd = self.frames[slot].cmd;
+        unsafe {
+            device.reset_fences(&[in_flight]).ctx("vkResetFences")?;
+            device
+                .reset_command_buffer(cmd, vk::CommandBufferResetFlags::empty())
+                .ctx("vkResetCommandBuffer")?;
+            let begin = vk::CommandBufferBeginInfo::default()
+                .flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT);
+            device
+                .begin_command_buffer(cmd, &begin)
+                .ctx("vkBeginCommandBuffer")?;
+        }
+
+        let swap_image = self.swapchain.frames()[image_index].image;
+        let swap_view = self.swapchain.frames()[image_index].view;
+        let extent = self.swapchain.extent();
+
+        // Цвет: UNDEFINED → COLOR_ATTACHMENT_OPTIMAL, глубина: UNDEFINED → DEPTH_ATTACHMENT.
+        {
+            let color_barrier = vk::ImageMemoryBarrier2::default()
+                .src_stage_mask(vk::PipelineStageFlags2::TOP_OF_PIPE)
+                .dst_stage_mask(vk::PipelineStageFlags2::COLOR_ATTACHMENT_OUTPUT)
+                .dst_access_mask(vk::AccessFlags2::COLOR_ATTACHMENT_WRITE)
+                .old_layout(vk::ImageLayout::UNDEFINED)
+                .new_layout(vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL)
+                .image(swap_image)
+                .subresource_range(color_range());
+            let depth_barrier = vk::ImageMemoryBarrier2::default()
+                .src_stage_mask(vk::PipelineStageFlags2::TOP_OF_PIPE)
+                .dst_stage_mask(
+                    vk::PipelineStageFlags2::EARLY_FRAGMENT_TESTS
+                        | vk::PipelineStageFlags2::LATE_FRAGMENT_TESTS,
+                )
+                .dst_access_mask(vk::AccessFlags2::DEPTH_STENCIL_ATTACHMENT_WRITE)
+                .old_layout(vk::ImageLayout::UNDEFINED)
+                .new_layout(vk::ImageLayout::DEPTH_ATTACHMENT_OPTIMAL)
+                .image(self.depth.image())
+                .subresource_range(depth_range());
+            let barriers = [color_barrier, depth_barrier];
+            let dependency = vk::DependencyInfo::default().image_memory_barriers(&barriers);
+            unsafe { device.cmd_pipeline_barrier2(cmd, &dependency) };
+        }
+
+        let color_attachment = vk::RenderingAttachmentInfo::default()
+            .image_view(swap_view)
+            .image_layout(vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL)
+            .load_op(vk::AttachmentLoadOp::CLEAR)
+            .store_op(vk::AttachmentStoreOp::STORE)
+            .clear_value(vk::ClearValue {
+                color: vk::ClearColorValue {
+                    float32: CLEAR_COLOR,
+                },
+            });
+        let depth_attachment = vk::RenderingAttachmentInfo::default()
+            .image_view(self.depth.view())
+            .image_layout(vk::ImageLayout::DEPTH_ATTACHMENT_OPTIMAL)
+            .load_op(vk::AttachmentLoadOp::CLEAR)
+            .store_op(vk::AttachmentStoreOp::DONT_CARE)
+            .clear_value(vk::ClearValue {
+                depth_stencil: vk::ClearDepthStencilValue {
+                    depth: 1.0,
+                    stencil: 0,
+                },
+            });
+        let color_attachments = [color_attachment];
+        let rendering = vk::RenderingInfo::default()
+            .render_area(vk::Rect2D {
+                offset: vk::Offset2D { x: 0, y: 0 },
+                extent,
+            })
+            .layer_count(1)
+            .color_attachments(&color_attachments)
+            .depth_attachment(&depth_attachment);
+
+        unsafe {
+            device.cmd_begin_rendering(cmd, &rendering);
+
+            // Область вывода и отсечения общие для обоих рендереров сцены.
+            let viewport = [vk::Viewport {
+                x: 0.0,
+                y: 0.0,
+                width: extent.width as f32,
+                height: extent.height as f32,
+                min_depth: 0.0,
+                max_depth: 1.0,
+            }];
+            let scissor = [vk::Rect2D {
+                offset: vk::Offset2D { x: 0, y: 0 },
+                extent,
+            }];
+            device.cmd_set_viewport(cmd, 0, &viewport);
+            device.cmd_set_scissor(cmd, 0, &scissor);
+        }
+
+        if frame_state.grid_visible {
+            self.grid_renderer.draw(cmd, &frame_state.view_proj);
+        }
+        if let Some(mesh) = &self.gpu_mesh {
+            self.mesh_renderer.draw(
+                cmd,
+                mesh,
+                &(frame_state.view_proj * self.model),
+                frame_state.render_mode,
+            );
+        }
+
+        self.egui_renderer
+            .cmd_draw(cmd, extent, output.pixels_per_point, &primitives)
+            .map_err(|e| VkError::Other(format!("egui cmd_draw: {e}")))?;
+
+        unsafe {
+            device.cmd_end_rendering(cmd);
+
+            // Цвет: COLOR_ATTACHMENT_OPTIMAL → PRESENT_SRC.
+            let present_barrier = [vk::ImageMemoryBarrier2::default()
+                .src_stage_mask(vk::PipelineStageFlags2::COLOR_ATTACHMENT_OUTPUT)
+                .src_access_mask(vk::AccessFlags2::COLOR_ATTACHMENT_WRITE)
+                .dst_stage_mask(vk::PipelineStageFlags2::BOTTOM_OF_PIPE)
+                .old_layout(vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL)
+                .new_layout(vk::ImageLayout::PRESENT_SRC_KHR)
+                .image(swap_image)
+                .subresource_range(color_range())];
+            let dependency = vk::DependencyInfo::default().image_memory_barriers(&present_barrier);
+            device.cmd_pipeline_barrier2(cmd, &dependency);
+            device
+                .end_command_buffer(cmd)
+                .ctx("vkEndCommandBuffer")?;
+        }
+
+        // ── Отправка и показ ─────────────────────────────────────────────────
+        let render_finished = self.render_finished[image_index];
+        let wait = [vk::SemaphoreSubmitInfo::default()
+            .semaphore(self.frames[slot].image_available)
+            .stage_mask(vk::PipelineStageFlags2::COLOR_ATTACHMENT_OUTPUT)];
+        let signal = [vk::SemaphoreSubmitInfo::default()
+            .semaphore(render_finished)
+            .stage_mask(vk::PipelineStageFlags2::ALL_GRAPHICS)];
+        let cmd_infos = [vk::CommandBufferSubmitInfo::default().command_buffer(cmd)];
+        let submit = [vk::SubmitInfo2::default()
+            .wait_semaphore_infos(&wait)
+            .command_buffer_infos(&cmd_infos)
+            .signal_semaphore_infos(&signal)];
+        unsafe { device.queue_submit2(self.context.graphics_queue(), &submit, in_flight) }
+            .ctx("vkQueueSubmit2")?;
+
+        let swapchains = [self.swapchain.handle()];
+        let wait_semaphores = [render_finished];
+        let indices = [image_index as u32];
+        let present = vk::PresentInfoKHR::default()
+            .wait_semaphores(&wait_semaphores)
+            .swapchains(&swapchains)
+            .image_indices(&indices);
+        let presented = unsafe {
+            self.context
+                .swapchain_loader()
+                .queue_present(self.context.graphics_queue(), &present)
+        };
+        match presented {
+            Ok(false) => {}
+            Ok(true) | Err(vk::Result::ERROR_OUT_OF_DATE_KHR) => {
+                self.recreate_swap_dependent(window)?;
+            }
+            Err(e) => {
+                return Err(VkError::Api {
+                    context: "vkQueuePresentKHR",
+                    source: e,
+                })
+            }
+        }
+
+        self.cursor = self.cursor.wrapping_add(1);
+        Ok(())
+    }
+
+    /// Пересобрать всё, что зависит от цепочки показа.
+    ///
+    /// Порядок важен и перенесён из C++-версии дословно: неудачный `vkAcquireNextImage`
+    /// может оставить семафор `image_available` взведённым, поэтому покадровые семафоры
+    /// пересоздаются целиком; число образов цепочки могло измениться, поэтому семафоры
+    /// «кадр готов» тоже; и только потом переcобираются конвейеры.
+    fn recreate_swap_dependent(&mut self, window: &simv_core::Window) -> Result<()> {
+        self.context.wait_idle();
+        self.swapchain.recreate(&self.context, window, true)?;
+        self.depth = create_depth(&self.context, self.swapchain.extent())?;
+
+        let device = self.context.device();
+        for frame in &mut self.frames {
+            unsafe { device.destroy_semaphore(frame.image_available, None) };
+            frame.image_available =
+                unsafe { device.create_semaphore(&vk::SemaphoreCreateInfo::default(), None) }
+                    .ctx("vkCreateSemaphore")?;
+        }
+        for semaphore in self.render_finished.drain(..) {
+            unsafe { device.destroy_semaphore(semaphore, None) };
+        }
+        for _ in 0..self.swapchain.frames().len() {
+            self.render_finished.push(
+                unsafe { device.create_semaphore(&vk::SemaphoreCreateInfo::default(), None) }
+                    .ctx("vkCreateSemaphore")?,
+            );
+        }
+
+        let color_format = self.swapchain.color_format();
+        self.mesh_renderer
+            .ensure_pipelines(&self.context, color_format, DEPTH_FORMAT)?;
+        self.grid_renderer
+            .ensure_pipeline(&self.context, color_format, DEPTH_FORMAT)?;
+        self.egui_renderer
+            .set_render_mode(egui_ash_renderer::RenderMode::DynamicRendering(
+                dynamic_rendering(&self.swapchain),
+            ))
+            .map_err(|e| VkError::Other(format!("egui set_render_mode: {e}")))?;
+        Ok(())
+    }
+}
+
+impl Drop for Renderer {
+    fn drop(&mut self) {
+        self.context.wait_idle();
+        let device = self.context.device();
+        unsafe {
+            for frame in &self.frames {
+                device.destroy_fence(frame.in_flight, None);
+                device.destroy_semaphore(frame.image_available, None);
+                device.destroy_command_pool(frame.cmd_pool, None);
+            }
+            for &semaphore in &self.render_finished {
+                device.destroy_semaphore(semaphore, None);
+            }
+            device.destroy_command_pool(self.egui_pool, None);
+        }
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+//  Вспомогательное
+// ─────────────────────────────────────────────────────────────────────────────
+
+fn color_range() -> vk::ImageSubresourceRange {
+    vk::ImageSubresourceRange {
+        aspect_mask: vk::ImageAspectFlags::COLOR,
+        base_mip_level: 0,
+        level_count: 1,
+        base_array_layer: 0,
+        layer_count: 1,
+    }
+}
+
+fn depth_range() -> vk::ImageSubresourceRange {
+    vk::ImageSubresourceRange {
+        aspect_mask: vk::ImageAspectFlags::DEPTH,
+        base_mip_level: 0,
+        level_count: 1,
+        base_array_layer: 0,
+        layer_count: 1,
+    }
+}
+
+/// Форматы вложений для конвейера egui. Глубина здесь не для того, чтобы egui её
+/// использовал, а чтобы его конвейер совпал с проходом: интерфейс рисуется в тот же
+/// `vkCmdBeginRendering`, что и сцена, а у прохода есть глубинное вложение.
+fn dynamic_rendering(swapchain: &Swapchain) -> DynamicRendering {
+    DynamicRendering {
+        color_attachment_format: swapchain.color_format(),
+        depth_attachment_format: Some(DEPTH_FORMAT),
+        stencil_attachment_format: None,
+    }
+}
+
+fn egui_options() -> Options {
+    Options {
+        in_flight_frames: FRAMES_IN_FLIGHT,
+        // Интерфейс рисуется поверх сцены и в глубину не пишет.
+        enable_depth_test: false,
+        enable_depth_write: false,
+        // Цель показа в формате UNORM, значит перевод в sRGB делает фрагментный шейдер.
+        srgb_framebuffer: false,
+    }
+}
+
+fn create_depth(ctx: &Context, extent: vk::Extent2D) -> Result<Image> {
+    Image::new(
+        ctx,
+        "depth",
+        &ImageDesc {
+            extent: vk::Extent3D {
+                width: extent.width.max(1),
+                height: extent.height.max(1),
+                depth: 1,
+            },
+            format: DEPTH_FORMAT,
+            usage: vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT,
+            image_type: vk::ImageType::TYPE_2D,
+            view_type: vk::ImageViewType::TYPE_2D,
+            aspect: vk::ImageAspectFlags::DEPTH,
+        },
+    )
+}
+
+fn create_frame_state(
+    ctx: &Context,
+    swapchain_image_count: usize,
+) -> Result<(Vec<FrameSlot>, Vec<vk::Semaphore>)> {
+    let device = ctx.device();
+    let mut frames = Vec::with_capacity(FRAMES_IN_FLIGHT);
+    for _ in 0..FRAMES_IN_FLIGHT {
+        let pool_ci = vk::CommandPoolCreateInfo::default()
+            .flags(vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER)
+            .queue_family_index(ctx.graphics_family());
+        let cmd_pool =
+            unsafe { device.create_command_pool(&pool_ci, None) }.ctx("vkCreateCommandPool")?;
+
+        let alloc_ci = vk::CommandBufferAllocateInfo::default()
+            .command_pool(cmd_pool)
+            .level(vk::CommandBufferLevel::PRIMARY)
+            .command_buffer_count(1);
+        let cmd = unsafe { device.allocate_command_buffers(&alloc_ci) }
+            .ctx("vkAllocateCommandBuffers")?[0];
+
+        let image_available =
+            unsafe { device.create_semaphore(&vk::SemaphoreCreateInfo::default(), None) }
+                .ctx("vkCreateSemaphore")?;
+        // Взведён при создании: первый кадр не должен ждать несуществующей отправки.
+        let fence_ci = vk::FenceCreateInfo::default().flags(vk::FenceCreateFlags::SIGNALED);
+        let in_flight =
+            unsafe { device.create_fence(&fence_ci, None) }.ctx("vkCreateFence")?;
+
+        frames.push(FrameSlot {
+            cmd_pool,
+            cmd,
+            image_available,
+            in_flight,
+            textures_to_free: Vec::new(),
+        });
+    }
+
+    // По одному семафору «кадр готов» на образ цепочки: он взводится при показе.
+    let mut render_finished = Vec::with_capacity(swapchain_image_count);
+    for _ in 0..swapchain_image_count {
+        render_finished.push(
+            unsafe { device.create_semaphore(&vk::SemaphoreCreateInfo::default(), None) }
+                .ctx("vkCreateSemaphore")?,
+        );
+    }
+
+    Ok((frames, render_finished))
+}

rust/crates/simv-vk/src/shader.rs

@@ -0,0 +1,55 @@
+//! Шейдерные модули — перенос `simv::vk::Shader`.
+//!
+//! Главное отличие от C++-версии: SPIR-V не ищется на диске, а зашит в исполняемый
+//! файл на этапе сборки (см. `build.rs`). Вместе с `FindSpvPath` исчезли и
+//! POST_BUILD-копирование каталога `spirv/`, и требование запускать редактор из
+//! каталога бинаря, и целый класс ошибок «шейдер не найден» во время выполнения:
+//! отсутствующий шейдер теперь ломает сборку, а не запуск.
+
+use std::io::Cursor;
+
+use ash::vk;
+
+use crate::error::{Ctx, Result};
+
+/// Скомпилированный SPIR-V, вшитый в бинарь. Пути соответствуют раскладке
+/// `shaders/editor/` в корне репозитория.
+pub mod spirv {
+    pub const MESH_VERT: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/editor/mesh.vert.spv"));
+    pub const MESH_FRAG: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/editor/mesh.frag.spv"));
+    pub const GRID_VERT: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/editor/grid.vert.spv"));
+    pub const GRID_FRAG: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/editor/grid.frag.spv"));
+}
+
+/// Владеющая обёртка над `VkShaderModule`: уничтожается на выходе из области
+/// видимости, в том числе если сборка конвейера завершилась ошибкой.
+pub struct ShaderModule {
+    device: ash::Device,
+    handle: vk::ShaderModule,
+}
+
+impl ShaderModule {
+    pub fn new(device: &ash::Device, spirv_bytes: &[u8]) -> Result<Self> {
+        // `read_spv` заодно снимает вопрос выравнивания: `include_bytes!` даёт срез
+        // байтов, а Vulkan хочет 32-битные слова.
+        let words = ash::util::read_spv(&mut Cursor::new(spirv_bytes))
+            .map_err(|e| crate::error::VkError::Other(format!("битый SPIR-V: {e}")))?;
+        let ci = vk::ShaderModuleCreateInfo::default().code(&words);
+        let handle =
+            unsafe { device.create_shader_module(&ci, None) }.ctx("vkCreateShaderModule")?;
+        Ok(Self {
+            device: device.clone(),
+            handle,
+        })
+    }
+
+    pub fn handle(&self) -> vk::ShaderModule {
+        self.handle
+    }
+}
+
+impl Drop for ShaderModule {
+    fn drop(&mut self) {
+        unsafe { self.device.destroy_shader_module(self.handle, None) };
+    }
+}

rust/crates/simv-vk/src/swapchain.rs

@@ -0,0 +1,182 @@
+//! Цепочка показа — перенос `simv::vk::Swapchain`.
+//!
+//! В C++ вся эта функция умещается в вызов `vkb::SwapchainBuilder`: формат, режим
+//! показа, число образов и представления создаются за него. Здесь то же самое сделано
+//! руками — выбор формата с откатом, зажим числа образов и размера по возможностям
+//! поверхности, создание представлений.
+
+use ash::vk;
+
+use crate::context::Context;
+use crate::error::{Ctx, Result};
+
+pub struct SwapchainFrame {
+    pub image: vk::Image,
+    pub view: vk::ImageView,
+}
+
+pub struct Swapchain {
+    device: ash::Device,
+    loader: ash::khr::swapchain::Device,
+    handle: vk::SwapchainKHR,
+    frames: Vec<SwapchainFrame>,
+    color_format: vk::Format,
+    extent: vk::Extent2D,
+}
+
+impl Swapchain {
+    pub fn new(ctx: &Context, window: &simv_core::Window, vsync: bool) -> Result<Self> {
+        let mut swapchain = Self {
+            device: ctx.device().clone(),
+            loader: ctx.swapchain_loader().clone(),
+            handle: vk::SwapchainKHR::null(),
+            frames: Vec::new(),
+            color_format: vk::Format::UNDEFINED,
+            extent: vk::Extent2D::default(),
+        };
+        swapchain.recreate(ctx, window, vsync)?;
+        Ok(swapchain)
+    }
+
+    pub fn handle(&self) -> vk::SwapchainKHR {
+        self.handle
+    }
+    pub fn frames(&self) -> &[SwapchainFrame] {
+        &self.frames
+    }
+    pub fn color_format(&self) -> vk::Format {
+        self.color_format
+    }
+    pub fn extent(&self) -> vk::Extent2D {
+        self.extent
+    }
+
+    /// Пересобрать цепочку под текущий размер окна. Старая уничтожается полностью:
+    /// `oldSwapchain` не используется — так же, как в C++-версии.
+    pub fn recreate(
+        &mut self,
+        ctx: &Context,
+        window: &simv_core::Window,
+        vsync: bool,
+    ) -> Result<()> {
+        ctx.wait_idle();
+        self.destroy();
+
+        let surface_loader = ctx.surface_loader();
+        let physical_device = ctx.physical_device();
+        let surface = ctx.surface();
+
+        let caps = unsafe {
+            surface_loader.get_physical_device_surface_capabilities(physical_device, surface)
+        }
+        .ctx("vkGetPhysicalDeviceSurfaceCapabilitiesKHR")?;
+        let formats =
+            unsafe { surface_loader.get_physical_device_surface_formats(physical_device, surface) }
+                .ctx("vkGetPhysicalDeviceSurfaceFormatsKHR")?;
+        let present_modes = unsafe {
+            surface_loader.get_physical_device_surface_present_modes(physical_device, surface)
+        }
+        .ctx("vkGetPhysicalDeviceSurfacePresentModesKHR")?;
+
+        // Желаемый формат тот же, что просит C++-версия; если его нет — первый доступный.
+        let wanted = vk::SurfaceFormatKHR {
+            format: vk::Format::B8G8R8A8_UNORM,
+            color_space: vk::ColorSpaceKHR::SRGB_NONLINEAR,
+        };
+        let surface_format = formats
+            .iter()
+            .copied()
+            .find(|f| f.format == wanted.format && f.color_space == wanted.color_space)
+            .unwrap_or_else(|| formats[0]);
+
+        // FIFO поддерживается всегда; MAILBOX может отсутствовать.
+        let desired_mode = if vsync {
+            vk::PresentModeKHR::FIFO
+        } else {
+            vk::PresentModeKHR::MAILBOX
+        };
+        let present_mode = present_modes
+            .iter()
+            .copied()
+            .find(|&m| m == desired_mode)
+            .unwrap_or(vk::PresentModeKHR::FIFO);
+
+        // `current_extent` со всеми битами в единицах означает «размер задаёт
+        // приложение» — тогда берём размер окна и зажимаем по пределам поверхности.
+        let (width, height) = window.framebuffer_size();
+        let extent = if caps.current_extent.width == u32::MAX {
+            vk::Extent2D {
+                width: width.clamp(caps.min_image_extent.width, caps.max_image_extent.width),
+                height: height.clamp(caps.min_image_extent.height, caps.max_image_extent.height),
+            }
+        } else {
+            caps.current_extent
+        };
+
+        let mut image_count = caps.min_image_count + 1;
+        if caps.max_image_count > 0 && image_count > caps.max_image_count {
+            image_count = caps.max_image_count;
+        }
+
+        let ci = vk::SwapchainCreateInfoKHR::default()
+            .surface(surface)
+            .min_image_count(image_count)
+            .image_format(surface_format.format)
+            .image_color_space(surface_format.color_space)
+            .image_extent(extent)
+            .image_array_layers(1)
+            .image_usage(
+                vk::ImageUsageFlags::COLOR_ATTACHMENT | vk::ImageUsageFlags::TRANSFER_DST,
+            )
+            .image_sharing_mode(vk::SharingMode::EXCLUSIVE)
+            .pre_transform(caps.current_transform)
+            .composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE)
+            .present_mode(present_mode)
+            .clipped(true);
+
+        self.handle =
+            unsafe { self.loader.create_swapchain(&ci, None) }.ctx("vkCreateSwapchainKHR")?;
+        self.color_format = surface_format.format;
+        self.extent = extent;
+
+        let images = unsafe { self.loader.get_swapchain_images(self.handle) }
+            .ctx("vkGetSwapchainImagesKHR")?;
+        self.frames.reserve(images.len());
+        for image in images {
+            let view_ci = vk::ImageViewCreateInfo::default()
+                .image(image)
+                .view_type(vk::ImageViewType::TYPE_2D)
+                .format(self.color_format)
+                .subresource_range(vk::ImageSubresourceRange {
+                    aspect_mask: vk::ImageAspectFlags::COLOR,
+                    base_mip_level: 0,
+                    level_count: 1,
+                    base_array_layer: 0,
+                    layer_count: 1,
+                });
+            let view = unsafe { self.device.create_image_view(&view_ci, None) }
+                .ctx("vkCreateImageView(swapchain)")?;
+            self.frames.push(SwapchainFrame { image, view });
+        }
+
+        Ok(())
+    }
+
+    fn destroy(&mut self) {
+        unsafe {
+            for frame in self.frames.drain(..) {
+                self.device.destroy_image_view(frame.view, None);
+            }
+            if self.handle != vk::SwapchainKHR::null() {
+                self.loader.destroy_swapchain(self.handle, None);
+                self.handle = vk::SwapchainKHR::null();
+            }
+        }
+    }
+}
+
+impl Drop for Swapchain {
+    fn drop(&mut self) {
+        self.destroy();
+    }
+}