feat: add walk mode scene collision

Author: robertvokac

include/MeshCraft/Editor/WalkController.hpp

@@ -5,9 +5,17 @@
 #include <Microsoft/Xna/Framework/Vector3.hpp>
 
 #include <optional>
+#include <span>
 
 namespace MeshCraft::Editor {
 
+// World-space axis-aligned solid used by walk mode. MeshCraft builds these
+// from opt-in MC3 objects with collision="box" when walk mode starts.
+struct WalkCollider {
+    float minX{0.0f}, minY{0.0f}, minZ{0.0f};
+    float maxX{0.0f}, maxY{0.0f}, maxZ{0.0f};
+};
+
 // SYS-W3-01 Phase 6: first-person "walk mode" extracted out of
 // MeshCraftApplication (H-series). Self-contained physics/camera state,
 // like KeybindingManager/Preferences/UndoManager -- no callback DI Context
@@ -25,6 +33,7 @@ class WalkController {
     float speed{5.0f};        // movement speed (m/s)
     float turnSpeed{1.5f};    // keyboard yaw speed (rad/s)
     float mouseSens{0.003f};  // mouse sensitivity (rad/px)
+    float collisionRadius{0.30f}; // horizontal player-cylinder radius (m)
 
     [[nodiscard]] bool  isActive() const { return active_; }
     [[nodiscard]] float posX() const { return posX_; }
@@ -61,7 +70,8 @@ class WalkController {
     std::optional<ExitCameraState> update(
         float dt,
         const Microsoft::Xna::Framework::Input::KeyboardState& ks,
-        int mouseDx, int mouseDy);
+        int mouseDx, int mouseDy,
+        std::span<const WalkCollider> colliders = {});
 
     // First-person view matrix from the current position/yaw/pitch/height.
     // The projection matrix is deliberately NOT owned here -- walk mode

include/MeshCraft/MeshCraftApplication.hpp

@@ -818,6 +818,7 @@ class MeshCraftApplication : public Microsoft::Xna::Framework::Game {
     // than carried forward)
     // -----------------------------------------------------------------------
     Editor::WalkController walkController_;
+    std::vector<Editor::WalkCollider> walkColliders_;
     void  updateWalkMode(float dt, const Microsoft::Xna::Framework::Input::KeyboardState& ks,
                          int mouseDx, int mouseDy);
     void  enterWalkMode();

plan.md

@@ -823,7 +823,25 @@ portable through CNA rather than merely hiding its OpenGL dependency.
   coverage. **Resolved:** commits `8cb14be`, `026fc2d`.
 - **SYS-W14-05** `[DEFERRED]` `P3` — Safe `embed:` mesh/resource support end-to-end. (`AUD-025`)
 - **SYS-W14-06** `[DEFERRED]` `P3` — Improved CSG output (smooth normals/UVs/materials).
-- **SYS-W14-07** `[DEFERRED]` `P3` — Improved walk/navigation collision.
+- **SYS-W14-07** `[DONE]` `P3` — Improved walk/navigation collision.
+  Walk mode previously treated only the global `y=0` plane as solid, so it
+  could pass through every scene wall, floor and ceiling. It now snapshots
+  every primitive object explicitly marked `collision="box"` when entering
+  walk mode, transforms its eight local bounds corners through its complete
+  parent hierarchy into a world AABB, and supplies those colliders to
+  `Editor::WalkController`. The controller uses a swept, radius-expanded AABB
+  test for horizontal player-cylinder movement (prevents long-frame
+  tunnelling and preserves tangent movement for wall sliding), resolves a
+  start inside a newly enabled collider, lands on box tops, and stops jumps
+  at box ceilings while retaining the existing `y=0` ground behavior.
+  The Properties panel already exposes the `box` collision mode; the walk HUD
+  reports the active collider count and exposes the collision radius. Other
+  serialized proxy labels (`sphere`, `mesh`, `convex`, `capsule`) remain
+  deliberately unsupported by walk mode rather than being approximated
+  silently. The real `walk_controller_test` now covers swept-wall blocking,
+  diagonal wall sliding, platform landing and ceiling blocking in addition to
+  the prior movement/gravity coverage. EASYGL `MeshCraft` and the targeted
+  test built and passed with `-j4` on 2026-07-25.
 - **SYS-W14-08** `[DONE]` `P2` — AI change preview/diff before destructive
   replace. Before this, "Apply to Scene" replaced `document_` wholesale
   with only two safety nets: full Undo, and `STAB-0395`'s

src/MeshCraft/Editor/WalkController.cpp

@@ -14,6 +14,107 @@ namespace {
 constexpr float kGravity   = -9.81f;
 constexpr float kJumpSpeed =  5.0f;
 constexpr float kPitchMax  =  1.48f; // ~85 degrees
+constexpr float kCollisionEpsilon = 1.0e-4f;
+
+bool verticallyOverlaps(const WalkCollider& c, float feetY, float height) {
+    return feetY < c.maxY - kCollisionEpsilon &&
+           feetY + height > c.minY + kCollisionEpsilon;
+}
+
+bool horizontallyOverlaps(const WalkCollider& c, float x, float z, float radius) {
+    return x >= c.minX - radius && x <= c.maxX + radius &&
+           z >= c.minZ - radius && z <= c.maxZ + radius;
+}
+
+// Raycast the player's horizontal centre through an AABB expanded by the
+// player radius. This is a swept test, so a long frame cannot tunnel through
+// a thin wall. normalX/normalZ identify the face that blocks the motion.
+bool sweepExpandedAabb(const WalkCollider& c, float x, float z, float dx, float dz,
+                       float radius, float& hitT, float& normalX, float& normalZ) {
+    const float minX = c.minX - radius, maxX = c.maxX + radius;
+    const float minZ = c.minZ - radius, maxZ = c.maxZ + radius;
+    float entryX, exitX, entryZ, exitZ;
+    if (std::abs(dx) < kCollisionEpsilon) {
+        if (x < minX || x > maxX) return false;
+        entryX = -INFINITY; exitX = INFINITY;
+    } else if (dx > 0.0f) {
+        entryX = (minX - x) / dx; exitX = (maxX - x) / dx;
+    } else {
+        entryX = (maxX - x) / dx; exitX = (minX - x) / dx;
+    }
+    if (std::abs(dz) < kCollisionEpsilon) {
+        if (z < minZ || z > maxZ) return false;
+        entryZ = -INFINITY; exitZ = INFINITY;
+    } else if (dz > 0.0f) {
+        entryZ = (minZ - z) / dz; exitZ = (maxZ - z) / dz;
+    } else {
+        entryZ = (maxZ - z) / dz; exitZ = (minZ - z) / dz;
+    }
+
+    const float entry = std::max(entryX, entryZ);
+    const float exit = std::min(exitX, exitZ);
+    if (entry > exit || exit < 0.0f || entry > 1.0f) return false;
+
+    hitT = std::max(0.0f, entry);
+    normalX = normalZ = 0.0f;
+    if (entryX > entryZ) normalX = dx > 0.0f ? -1.0f : 1.0f;
+    else                 normalZ = dz > 0.0f ? -1.0f : 1.0f;
+    return true;
+}
+
+void pushOutOfOverlaps(float& x, float& z, float feetY, float height, float radius,
+                       std::span<const WalkCollider> colliders) {
+    // A walk can start inside a newly-enabled collider. Resolve that state
+    // deterministically before the sweep, choosing the nearest expanded face.
+    for (int pass = 0; pass < 4; ++pass) {
+        bool moved = false;
+        for (const auto& c : colliders) {
+            if (!verticallyOverlaps(c, feetY, height) || !horizontallyOverlaps(c, x, z, radius)) continue;
+            const float left = x - (c.minX - radius);
+            const float right = (c.maxX + radius) - x;
+            const float front = z - (c.minZ - radius);
+            const float back = (c.maxZ + radius) - z;
+            const float nearest = std::min({left, right, front, back});
+            if (nearest == left)       x = c.minX - radius - kCollisionEpsilon;
+            else if (nearest == right) x = c.maxX + radius + kCollisionEpsilon;
+            else if (nearest == front) z = c.minZ - radius - kCollisionEpsilon;
+            else                       z = c.maxZ + radius + kCollisionEpsilon;
+            moved = true;
+        }
+        if (!moved) return;
+    }
+}
+
+void moveHorizontally(float& x, float& z, float feetY, float height, float radius,
+                      float dx, float dz, std::span<const WalkCollider> colliders) {
+    pushOutOfOverlaps(x, z, feetY, height, radius, colliders);
+    for (int pass = 0; pass < 4 && (std::abs(dx) > kCollisionEpsilon || std::abs(dz) > kCollisionEpsilon); ++pass) {
+        float bestT = 1.0f, normalX = 0.0f, normalZ = 0.0f;
+        bool blocked = false;
+        for (const auto& c : colliders) {
+            if (!verticallyOverlaps(c, feetY, height)) continue;
+            float hitT, hitNormalX, hitNormalZ;
+            if (sweepExpandedAabb(c, x, z, dx, dz, radius, hitT, hitNormalX, hitNormalZ) && hitT < bestT) {
+                bestT = hitT;
+                normalX = hitNormalX;
+                normalZ = hitNormalZ;
+                blocked = true;
+            }
+        }
+        if (!blocked) { x += dx; z += dz; return; }
+
+        const float safeT = std::max(0.0f, bestT - kCollisionEpsilon);
+        x += dx * safeT;
+        z += dz * safeT;
+        const float remaining = 1.0f - bestT;
+        dx *= remaining;
+        dz *= remaining;
+        // Remove the component into the blocking face, preserving the
+        // tangential component so diagonal movement slides along walls.
+        if (normalX != 0.0f) dx = 0.0f;
+        if (normalZ != 0.0f) dz = 0.0f;
+    }
+}
 } // namespace
 
 void WalkController::enter(Vector3 cameraPos, float cameraYaw) {
@@ -38,7 +139,8 @@ WalkController::ExitCameraState WalkController::exit() {
 }
 
 std::optional<WalkController::ExitCameraState> WalkController::update(
-    float dt, const KeyboardState& ks, int mouseDx, int mouseDy)
+    float dt, const KeyboardState& ks, int mouseDx, int mouseDy,
+    std::span<const WalkCollider> colliders)
 {
     if (ks.IsKeyDown(Keys::Escape))
         return exit();
@@ -67,14 +169,10 @@ std::optional<WalkController::ExitCameraState> WalkController::update(
     float sinY = std::sin(yaw_);
     float cosY = std::cos(yaw_);
 
-    if (fwd) {
-        posX_ += sinY * speed * dt;
-        posZ_ -= cosY * speed * dt;
-    }
-    if (back) {
-        posX_ -= sinY * speed * dt;
-        posZ_ += cosY * speed * dt;
-    }
+    float moveX = 0.0f, moveZ = 0.0f;
+    if (fwd)  { moveX += sinY * speed * dt; moveZ -= cosY * speed * dt; }
+    if (back) { moveX -= sinY * speed * dt; moveZ += cosY * speed * dt; }
+    moveHorizontally(posX_, posZ_, posY_, height, collisionRadius, moveX, moveZ, colliders);
 
     // Jump: Ctrl (only when on ground)
     bool ctrl = ks.IsKeyDown(Keys::LeftControl) || ks.IsKeyDown(Keys::RightControl);
@@ -83,14 +181,38 @@ std::optional<WalkController::ExitCameraState> WalkController::update(
         onGround_ = false;
     }
 
-    // Gravity + ground collision
+    // Gravity + y=0 ground collision + opt-in box-collider floors/ceilings.
     velY_  += kGravity * dt;
-    posY_  += velY_ * dt;
-
-    if (posY_ <= 0.0f) {
-        posY_     = 0.0f;
-        velY_     = 0.0f;
-        onGround_ = true;
+    const float oldY = posY_;
+    float nextY = posY_ + velY_ * dt;
+    onGround_ = false;
+    if (velY_ <= 0.0f) {
+        float landingY = 0.0f;
+        for (const auto& c : colliders) {
+            if (!horizontallyOverlaps(c, posX_, posZ_, collisionRadius)) continue;
+            if (oldY >= c.maxY - kCollisionEpsilon && nextY <= c.maxY + kCollisionEpsilon)
+                landingY = std::max(landingY, c.maxY);
+        }
+        if (nextY <= landingY) {
+            posY_ = landingY;
+            velY_ = 0.0f;
+            onGround_ = true;
+        } else {
+            posY_ = nextY;
+        }
+    } else {
+        float ceilingY = INFINITY;
+        for (const auto& c : colliders) {
+            if (!horizontallyOverlaps(c, posX_, posZ_, collisionRadius)) continue;
+            if (oldY + height <= c.minY + kCollisionEpsilon && nextY + height >= c.minY - kCollisionEpsilon)
+                ceilingY = std::min(ceilingY, c.minY);
+        }
+        if (ceilingY < INFINITY) {
+            posY_ = ceilingY - height;
+            velY_ = 0.0f;
+        } else {
+            posY_ = nextY;
+        }
     }
 
     return std::nullopt;

src/MeshCraft/MeshCraftApplication_WalkMode.cpp

@@ -3,14 +3,103 @@
 
 #include <Microsoft/Xna/Framework/Input/Keys.hpp>
 #include <Microsoft/Xna/Framework/Input/KeyboardState.hpp>
+#include <Microsoft/Xna/Framework/Matrix.hpp>
+#include <Microsoft/Xna/Framework/Vector3.hpp>
 
+#include <array>
+#include <cmath>
 #include <cstdio>
+#include <functional>
+#include <limits>
+#include <numbers>
+#include <optional>
 
 #include <imgui.h>
 
 namespace MeshCraft {
 
 using namespace Microsoft::Xna::Framework::Input;
+using namespace Microsoft::Xna::Framework;
+
+namespace {
+
+Matrix walkColliderWorldMatrix(const Mc3::Mc3Transform& t) {
+    constexpr float radiansPerDegree = std::numbers::pi_v<float> / 180.0f;
+    const float px = t.pivot[0], py = t.pivot[1], pz = t.pivot[2];
+    return Matrix::CreateTranslation({-px, -py, -pz}) *
+           Matrix::CreateScale({t.scale[0], t.scale[1], t.scale[2]}) *
+           Matrix::CreateFromYawPitchRoll(t.rotation[1] * radiansPerDegree,
+                                          t.rotation[0] * radiansPerDegree,
+                                          t.rotation[2] * radiansPerDegree) *
+           Matrix::CreateTranslation({t.position[0] + px, t.position[1] + py, t.position[2] + pz});
+}
+
+std::optional<std::array<float, 3>> walkColliderHalfExtents(const Mc3::Mc3Object& obj) {
+    if (!obj.primitive) return std::nullopt;
+    const auto& p = *obj.primitive;
+    const float radius = std::abs(p.radius);
+    const float halfHeight = std::abs(p.height) * 0.5f;
+    const float thin = 0.025f; // planes/disks still need a usable solid AABB
+    switch (p.primitiveType) {
+    case Mc3::PrimitiveType::Box:
+    case Mc3::PrimitiveType::Cube:
+        return std::array<float, 3>{std::abs(p.size[0]) * 0.5f,
+                                    std::abs(p.size[1]) * 0.5f,
+                                    std::abs(p.size[2]) * 0.5f};
+    case Mc3::PrimitiveType::Sphere:
+    case Mc3::PrimitiveType::IcoSphere:
+        return std::array<float, 3>{radius, radius, radius};
+    case Mc3::PrimitiveType::Cylinder:
+    case Mc3::PrimitiveType::Cone:
+    case Mc3::PrimitiveType::Capsule:
+        if (p.axis == "x") return std::array<float, 3>{halfHeight, radius, radius};
+        if (p.axis == "z") return std::array<float, 3>{radius, radius, halfHeight};
+        return std::array<float, 3>{radius, halfHeight, radius};
+    case Mc3::PrimitiveType::Plane:
+    case Mc3::PrimitiveType::Grid:
+        return std::array<float, 3>{std::abs(p.size[0]) * 0.5f, thin,
+                                    std::abs(p.size[2]) * 0.5f};
+    case Mc3::PrimitiveType::Disk:
+        return std::array<float, 3>{radius, thin, radius};
+    case Mc3::PrimitiveType::Torus: {
+        const float outerRadius = std::abs(p.majorRadius) + std::abs(p.minorRadius);
+        return std::array<float, 3>{outerRadius, std::abs(p.minorRadius), outerRadius};
+    }
+    }
+    return std::nullopt;
+}
+
+std::vector<Editor::WalkCollider> buildWalkColliders(const Mc3::Mc3Document& doc) {
+    std::vector<Editor::WalkCollider> colliders;
+    const Matrix identity = Matrix::getIdentityProperty();
+    std::function<void(const Mc3::Mc3Object&, const Matrix&, int)> visit;
+    visit = [&](const Mc3::Mc3Object& obj, const Matrix& parentWorld, int depth) {
+        if (depth > 16) return; // same graph-safety bound as SceneRenderer
+        const Matrix world = walkColliderWorldMatrix(obj.transform) * parentWorld;
+        if (obj.collision == "box") {
+            if (const auto extents = walkColliderHalfExtents(obj)) {
+                Editor::WalkCollider collider;
+                collider.minX = collider.minY = collider.minZ = std::numeric_limits<float>::infinity();
+                collider.maxX = collider.maxY = collider.maxZ = -std::numeric_limits<float>::infinity();
+                for (int sx : {-1, 1}) for (int sy : {-1, 1}) for (int sz : {-1, 1}) {
+                    const Vector3 p = Vector3::Transform(
+                        Vector3(sx * (*extents)[0], sy * (*extents)[1], sz * (*extents)[2]), world);
+                    collider.minX = std::min(collider.minX, p.X); collider.maxX = std::max(collider.maxX, p.X);
+                    collider.minY = std::min(collider.minY, p.Y); collider.maxY = std::max(collider.maxY, p.Y);
+                    collider.minZ = std::min(collider.minZ, p.Z); collider.maxZ = std::max(collider.maxZ, p.Z);
+                }
+                colliders.push_back(collider);
+            }
+        }
+        for (const auto& child : obj.children)
+            if (child) visit(*child, world, depth + 1);
+    };
+    for (const auto& obj : doc.objects)
+        if (obj) visit(*obj, identity, 0);
+    return colliders;
+}
+
+} // namespace
 
 // SYS-W3-01 Phase 6: the movement/look physics and the view-matrix
 // computation now live in the self-contained, CNA-coupled-where-
@@ -23,12 +112,15 @@ using namespace Microsoft::Xna::Framework::Input;
 // themselves).
 
 void MeshCraftApplication::enterWalkMode() {
+    walkColliders_ = buildWalkColliders(document_);
     walkController_.enter(camera_.position(), camera_.yaw);
-    setStatusMsg("Walk mode — Esc to exit", false, 3.0f);
+    setStatusMsg("Walk mode — " + std::to_string(walkColliders_.size()) +
+                 " box collider(s), Esc to exit", false, 3.0f);
 }
 
 void MeshCraftApplication::exitWalkMode() {
     auto s = walkController_.exit();
+    walkColliders_.clear();
     camera_.target   = s.target;
     camera_.yaw      = s.yaw;
     camera_.pitch    = s.pitch;
@@ -40,7 +132,8 @@ void MeshCraftApplication::updateWalkMode(float dt,
                                            const KeyboardState& ks,
                                            int mouseDx, int mouseDy)
 {
-    if (auto exitState = walkController_.update(dt, ks, mouseDx, mouseDy)) {
+    if (auto exitState = walkController_.update(dt, ks, mouseDx, mouseDy, walkColliders_)) {
+        walkColliders_.clear();
         camera_.target   = exitState->target;
         camera_.yaw      = exitState->yaw;
         camera_.pitch    = exitState->pitch;
@@ -97,6 +190,9 @@ void MeshCraftApplication::drawWalkModeHud(int screenW, int screenH) {
     ImGui::Text("Mouse sensitivity");
     ImGui::SetNextItemWidth(140);
     ImGui::SliderFloat("##wm", &walkController_.mouseSens, 0.001f, 0.010f, "%.3f", ImGuiSliderFlags_AlwaysClamp);
+    ImGui::Text("Collision radius (m)");
+    ImGui::SetNextItemWidth(140);
+    ImGui::SliderFloat("##wcr", &walkController_.collisionRadius, 0.10f, 1.00f, "%.2f", ImGuiSliderFlags_AlwaysClamp);
     if (ImGui::Button("Exit Walk Mode (Esc)"))
         exitWalkMode();
     ImGui::End();