// The Insert menu's mouse: what a point over it is on. The menu records each control's rectangle as it draws it (Map::add, in // the window image's pixels), and the next frame's mouse is tested against them (Map::at): the picture and the hit-test cannot // drift apart, at any size. Plain arithmetic, no Vulkan or ImGui: tests/test_menu_hit.cpp checks it. #pragma once namespace mkwvk::menu_hit { enum Part { kNone, // off the menu's controls (still over the menu: a click does nothing) kOutside, // off the menu kTabPrev, // the tab strip's left end kTab, // a tab: index kTabNext, // its right end kRow, // an option's row: index (the tab's own), side -1 the value's left half, 1 its right half, 0 the name kSlider, // a slider row's track: index, permille 0 to 1000 along it kCtlOption, // the Controls page: one of its own rows above the grid (index), side -1 the value's left half, 1 its right // half, 0 the name kCtlRow, // the Controls page: a row's name (index; index == the count: Reset to defaults) kCtlCell, // a binding: index the row, side 0 the gamepad's, 1 the keyboard's kListLine, // a list (the teleport list, the inventory): a line as shown (index, 0 the top one), side -1 the left half, 1 the right half kButton, // the restart question's buttons: index 0 Later, 1 Restart now }; struct Hit { Part part = kNone; int index = -1; int side = 0; int permille = 0; }; /// A point in the window's pixels (the cursor's, in a window win_w x win_h pixels) in the window's image (img_w x img_h: /// the swapchain's; the same size as a rule, but not while a resize is on its way) inline void to_image(int x, int y, int win_w, int win_h, int img_w, int img_h, int* ix, int* iy) { *ix = win_w > 0 ? (int)((long long)x * img_w / win_w) : x; *iy = win_h > 0 ? (int)((long long)y * img_h / win_h) : y; } /// A slider's value for a point along its track (lo to hi in steps of step), nearest step, held to its ends inline int slider_value(int permille, int lo, int hi, int step) { if (step <= 0 || hi <= lo) return lo; const int steps = (hi - lo) / step; const int k = (permille * steps + 500) / 1000; return lo + (k < 0 ? 0 : k > steps ? steps : k) * step; } /// Where along the track a value is, in permille (the knob's place) inline int slider_permille(int v, int lo, int hi) { if (hi <= lo) return 0; const int p = (int)((long long)(v - lo) * 1000 / (hi - lo)); return p < 0 ? 0 : p > 1000 ? 1000 : p; } /// The controls as last drawn struct Map { struct Box { float x0, y0, x1, y1; Part part; int index; float v0, v1; // (a value's span, for its halves: side -1 left of the middle, 1 right; v0 >= v1: none) float t0, t1; // (a slider's track: kSlider along it; t0 >= t1: none) int side; // (a fixed side: the Controls page's cells) }; static constexpr int kMax = 96; static constexpr float kGrab = 6; // (a click this far past either end of a track still takes the end, in pixels) Box box[kMax]; int n = 0; float ax0 = 0, ay0 = 0, ax1 = 0, ay1 = 0; // (the menu's area: off it, kOutside) void clear(float x0, float y0, float x1, float y1) { n = 0, ax0 = x0, ay0 = y0, ax1 = x1, ay1 = y1; } void add(float x0, float y0, float x1, float y1, Part part, int index, float v0 = 0, float v1 = 0, float t0 = 0, float t1 = 0, int side = 0) { if (n < kMax) box[n++] = {x0, y0, x1, y1, part, index, v0, v1, t0, t1, side}; } Hit at(float x, float y) const { Hit hit; if (x < ax0 || y < ay0 || x >= ax1 || y >= ay1) return hit.part = kOutside, hit; for (int i = n - 1; i >= 0; i--) { // (the last drawn on top) const Box& b = box[i]; if (x < b.x0 || y < b.y0 || x >= b.x1 || y >= b.y1) continue; hit.part = b.part, hit.index = b.index, hit.side = b.side; if (b.t0 < b.t1 && x >= b.t0 - kGrab && x < b.t1 + kGrab) { hit.part = kSlider; hit.permille = permille(b, x); return hit; } if (b.v0 < b.v1 && x >= b.v0 && x < b.v1) hit.side = x < (b.v0 + b.v1) / 2 ? -1 : 1; return hit; } return hit; } /// A drag that started on row's slider: the point's place along its track, held to its ends, wherever the cursor went; /// -1 when the row has no track now int drag(float x, int row) const { for (int i = 0; i < n; i++) if (box[i].part == kRow && box[i].index == row && box[i].t0 < box[i].t1) return permille(box[i], x); return -1; } static int permille(const Box& b, float x) { const int p = (int)((x - b.t0) * 1000 / (b.t1 - b.t0)); return p < 0 ? 0 : p > 1000 ? 1000 : p; } }; } // namespace mkwvk::menu_hit