// (triforce) The start-up screen while the shaders are prepared (vk_main.cpp prepare_with_screen; vk_menu.cpp draw_startup // calls draw): "the relic in a dark hall", the look the start client has (setup/, the tokens in the lab's ui/style_tokens.md). // The crest (assets/triforce.png, vk_imgui.h logo) is the only picture: a warm near-black hall, one soft light, gold hairlines, // quiet type. Its three stones are the only saturated things and carry the state: a stone a part of the preparation, unlit // until the part is done (vk_progress.h stones_lit); the unlit crest and the stones' own pixels are made here from the crest, // once, with the steps the start client uses, so both show the same thing. Under it one line of progress with what is being // done, how far, and how long it has left as far as the measured rate says. // Drawn with ImGui's draw lists alone (no shader of ours: the glows are meshes with a colour a vertex); sizes are the tokens' // pixels of a 640-line window. Everything eases on the caller's clock, so a test can draw any moment of it. #pragma once #define IMGUI_DEFINE_MATH_OPERATORS #include #include #include #include #include #include #include #include "imgui.h" #include "imgui_internal.h" // (RegisterUserTexture; the baked glyphs) #include "vk_progress.h" #include "vk_ui.h" namespace mkwvk::start_screen { // ---- the tokens: colour ---- constexpr ImU32 hex(unsigned rgb, int a = 255) { return IM_COL32(rgb >> 16 & 255, rgb >> 8 & 255, rgb & 255, a); } constexpr unsigned kInk900 = 0x0A0908, kInk600 = 0x262017, kLine = 0x2C2518, kTextHi = 0xF3EAD5, kText = 0xCDC2A8, kTextDim = 0x948A70, kTextFaint = 0x5F5744, kGold100 = 0xFFF4CC, kGold300 = 0xF7DC8C, kGold500 = 0xE0B23E, kTopLight = 0xFFECAA; // (the stones in the order they count: emerald, sapphire, ruby) constexpr unsigned kStoneGlow[3] = {0x7CFF9A, 0x8FC0FF, 0xFF7A84}; constexpr float kStoneAt[3][2] = {{0.53f, 0.32f}, {0.71f, 0.68f}, {0.30f, 0.64f}}; // (their centres in the crest's box) inline float clamp01(float t) { return t < 0 ? 0 : t > 1 ? 1 : t; } inline float ease_out(float t) { t = 1 - clamp01(t); return 1 - t * t * t * t * t; } // (cubic-bezier(0.22, 1, 0.36, 1)) inline float ease_io(float t) { return 0.5f - 0.5f * std::cos(3.14159265f * clamp01(t)); } inline float lerp(float a, float b, float t) { return a + (b - a) * t; } /// A loop between lo and 1, period seconds a cycle, phase in cycles inline float breath(double now, float period, float lo, float phase = 0) { return lerp(lo, 1.0f, 0.5f - 0.5f * (float)std::cos((now / period + phase) * 6.283185307)); } /// (the window's images blend in linear light: an sRGB surface with no UNORM view, vk_imgui.cpp. A light of alpha a over /// the dark hall then comes out far brighter than the same alpha blended on the coded values, as everywhere else: its alpha is /// taken to the power that gives the same light) inline float blend_power = 1; inline ImU32 light(unsigned rgb, float a) { a = clamp01(a); if (blend_power != 1) a = std::pow(a, blend_power); return hex(rgb, (int)(a * 255 + 0.5f)); } inline ImU32 ink(unsigned rgb, float a) { return hex(rgb, (int)(clamp01(a) * 255 + 0.5f)); } // ---- the crest's layers, made once from its pixels (the start client's steps: setup/Art.cs) ---- struct Art { bool tried = false, released = false; int w = 0, h = 0; ImTextureData* dim = nullptr; // (the crest, its stones unlit: dark glass) ImTextureData* stone[3] = {}; // (each stone's own pixels: over dim at alpha 1 it is lit) ImTextureData* shape = nullptr; // (white in the crest's alpha: the gleam) ImTextureData* grain = nullptr; // (noise: the hall's grain, which also hides the gradients' steps) }; inline Art art; inline ImTextureData* texture_of(int w, int h, const unsigned char* rgba) { ImTextureData* t = IM_NEW(ImTextureData)(); t->Create(ImTextureFormat_RGBA32, w, h); memcpy(t->GetPixels(), rgba, (size_t)w * h * 4); t->UseColors = true; ImGui::RegisterUserTexture(t); return t; } /// A square maximum or minimum over (2r+1)^2, in place inline void spread(std::vector& m, int w, int h, int r, bool grow) { std::vector t(m.size()); for (int pass = 0; pass < 2; pass++) { // (rows, then columns) for (int y = 0; y < h; y++) for (int x = 0; x < w; x++) { unsigned char v = grow ? 0 : 255; for (int k = -r; k <= r; k++) { const int xx = pass ? x : x + k, yy = pass ? y + k : y; if (xx < 0 || yy < 0 || xx >= w || yy >= h) continue; const unsigned char s = m[(size_t)yy * w + xx]; v = grow ? std::max(v, s) : std::min(v, s); } t[(size_t)y * w + x] = v; } m.swap(t); } } /// The three stones' masks (0 to 1) in a crest of w x h straight RGBA: the stone's hue inside its box, small gaps closed, its /// holes filled (whatever the outside cannot reach), grown a pixel, feathered. The numbers are for the 512 x 468 crest inline void stone_masks(const unsigned char* px, int w, int h, std::vector mask[3]) { struct Spec { float h0, h1, sat, val; int box[4]; }; static const Spec specs[3] = {{75, 175, 0.30f, 0.10f, {190, 80, 340, 225}}, // emerald {190, 265, 0.30f, 0.10f, {265, 225, 460, 410}}, // sapphire {332, 378, 0.40f, 0.12f, {80, 225, 225, 370}}}; // ruby (hue above 332 or under 18) const float sx = w / 512.0f, sy = h / 468.0f; for (int k = 0; k < 3; k++) { const Spec& sp = specs[k]; std::vector m((size_t)w * h, 0); const int x0 = (int)(sp.box[0] * sx), y0 = (int)(sp.box[1] * sy), x1 = std::min(w, (int)(sp.box[2] * sx)), y1 = std::min(h, (int)(sp.box[3] * sy)); for (int y = y0; y < y1; y++) for (int x = x0; x < x1; x++) { const unsigned char* p = px + ((size_t)y * w + x) * 4; const float r = p[0] / 255.0f, g = p[1] / 255.0f, b = p[2] / 255.0f, mx = std::max(r, std::max(g, b)), mn = std::min(r, std::min(g, b)), d = mx - mn; if (p[3] <= 127 || d <= 1e-6f || d / mx <= sp.sat || mx <= sp.val) continue; float hue = mx == r ? std::fmod((g - b) / d + 6.0f, 6.0f) : mx == g ? (b - r) / d + 2 : (r - g) / d + 4; hue *= 60; if (hue < 18) hue += 360; // (the ruby's window goes through 0) if (hue > sp.h0 && hue < sp.h1) m[(size_t)y * w + x] = 255; } spread(m, w, h, 2, true), spread(m, w, h, 2, false); // (the outside flooded from a corner, through its four neighbours: what it does not reach is the stone and its holes) std::vector out((size_t)w * h, 0); std::vector stack{0}; out[0] = 1; while (!stack.empty()) { const int at = stack.back(), x = at % w, y = at / w; stack.pop_back(); const int next[4] = {x > 0 ? at - 1 : -1, x + 1 < w ? at + 1 : -1, y > 0 ? at - w : -1, y + 1 < h ? at + w : -1}; for (int n : next) if (n >= 0 && !out[n] && !m[n]) out[n] = 1, stack.push_back(n); } for (size_t i = 0; i < m.size(); i++) m[i] = out[i] ? 0 : 255; spread(m, w, h, 1, true); // (feathered: a Gaussian of 1.2 pixels) float kern[9], sum = 0; for (int i = -4; i <= 4; i++) sum += kern[i + 4] = std::exp(-(float)(i * i) / (2 * 1.2f * 1.2f)); std::vector a((size_t)w * h), t((size_t)w * h); for (size_t i = 0; i < m.size(); i++) a[i] = m[i] / 255.0f; for (int pass = 0; pass < 2; pass++) { for (int y = 0; y < h; y++) for (int x = 0; x < w; x++) { float v = 0; for (int i = -4; i <= 4; i++) { const int xx = std::clamp(pass ? x : x + i, 0, w - 1), yy = std::clamp(pass ? y + i : y, 0, h - 1); v += a[(size_t)yy * w + xx] * kern[i + 4]; } t[(size_t)y * w + x] = v / sum; } a.swap(t); } mask[k] = std::move(a); } } /// The layers from the crest's pixels: dim (the stones drained to a cold dark glass), each stone's own pixels, the shape inline void crest_layers(const unsigned char* px, int w, int h, std::vector& dim, std::vector stone[3], std::vector& shape) { std::vector mask[3]; stone_masks(px, w, h, mask); const size_t n = (size_t)w * h; dim.assign(px, px + n * 4); shape.assign(n * 4, 255); for (size_t i = 0; i < n; i++) shape[i * 4 + 3] = px[i * 4 + 3]; for (int k = 0; k < 3; k++) { stone[k].assign(px, px + n * 4); for (size_t i = 0; i < n; i++) { const float m = mask[k][i]; stone[k][i * 4 + 3] = (unsigned char)(px[i * 4 + 3] * m + 0.5f); if (m <= 0) continue; const float lum = (0.299f * px[i * 4] + 0.587f * px[i * 4 + 1] + 0.114f * px[i * 4 + 2]) / 255.0f; const float unlit[3] = {lum * 0.30f + 0.020f, lum * 0.28f + 0.018f, lum * 0.26f + 0.016f}; for (int ch = 0; ch < 3; ch++) dim[i * 4 + ch] = (unsigned char)std::clamp(dim[i * 4 + ch] * (1 - m) + unlit[ch] * 255.0f * m + 0.5f, 0.0f, 255.0f); } } } /// The textures, at the first drawing (ImGui's context exists then). Without the crest (a source tree that has no picture) /// the screen is its type and its line alone inline void art_make() { if (art.tried) return; art.tried = true; float aspect = 1; ImTextureData* crest = ui::logo(&aspect); const auto t0 = std::chrono::steady_clock::now(); if (crest && crest->Format == ImTextureFormat_RGBA32 && crest->GetPixels() && crest->Width > 8 && crest->Height > 8) { std::vector dim, stone[3], shape; art.w = crest->Width, art.h = crest->Height; crest_layers((const unsigned char*)crest->GetPixels(), art.w, art.h, dim, stone, shape); art.dim = texture_of(art.w, art.h, dim.data()); for (int k = 0; k < 3; k++) art.stone[k] = texture_of(art.w, art.h, stone[k].data()); art.shape = texture_of(art.w, art.h, shape.data()); } std::vector noise((size_t)256 * 256 * 4); uint32_t seed = 0x2F6E2B1u; for (size_t i = 0; i < noise.size(); i += 4) { seed = seed * 1664525u + 1013904223u; noise[i] = noise[i + 1] = noise[i + 2] = (unsigned char)(seed >> 24), noise[i + 3] = 255; } art.grain = texture_of(256, 256, noise.data()); logf("vk: start-up: the crest's layers made in %.1f ms (%dx%d)", std::chrono::duration(std::chrono::steady_clock::now() - t0).count(), art.w, art.h); } /// The textures let go, inside an ImGui frame that draws none of them: this frame's recording destroys the GPU's part /// (vk_imgui.cpp, some frames later). WantDestroyNextFrame says the destroy is ours: without it ImGui takes a destroyed /// texture for one the backend lost, and asks for it again at the next frame. The pixels go now; the small records stay /// registered (ImGui walks them at every frame) inline void art_release() { if (art.released) return; art.released = true; ImTextureData** all[] = {&art.dim, &art.stone[0], &art.stone[1], &art.stone[2], &art.shape, &art.grain}; for (ImTextureData** t : all) { if (!*t) continue; const bool made = (*t)->BackendUserData || (*t)->TexID != ImTextureID_Invalid; // (on the GPU; else there is nothing to destroy there) (*t)->WantDestroyNextFrame = true; (*t)->SetStatus(made ? ImTextureStatus_WantDestroy : ImTextureStatus_Destroyed); (*t)->DestroyPixels(); *t = nullptr; } } // ---- drawing: meshes with a colour a vertex ---- /// A light round m: rings at rr (shares of the radii rx, ry, the first 0) with the alphas aa inline void radial(ImDrawList* d, ImVec2 m, float rx, float ry, unsigned rgb, const float* rr, const float* aa, int n, float k = 1) { const int seg = 72; const ImVec2 uv = d->_Data->TexUvWhitePixel; d->PrimReserve((seg * 3) + (n - 2) * seg * 6, 1 + (n - 1) * seg); const unsigned base = d->_VtxCurrentIdx; d->PrimWriteVtx(m, uv, light(rgb, aa[0] * k)); for (int i = 1; i < n; i++) for (int s = 0; s < seg; s++) { const float a = s * 6.283185307f / seg; d->PrimWriteVtx(ImVec2(m.x + std::cos(a) * rx * rr[i], m.y + std::sin(a) * ry * rr[i]), uv, light(rgb, aa[i] * k)); } for (int s = 0; s < seg; s++) { const int s1 = (s + 1) % seg; d->PrimWriteIdx((ImDrawIdx)base), d->PrimWriteIdx((ImDrawIdx)(base + 1 + s)), d->PrimWriteIdx((ImDrawIdx)(base + 1 + s1)); } for (int i = 1; i + 1 < n; i++) for (int s = 0; s < seg; s++) { const int s1 = (s + 1) % seg; const unsigned a = base + 1 + (i - 1) * seg + s, b = base + 1 + (i - 1) * seg + s1, c2 = base + 1 + i * seg + s1, e = base + 1 + i * seg + s; d->PrimWriteIdx((ImDrawIdx)a), d->PrimWriteIdx((ImDrawIdx)b), d->PrimWriteIdx((ImDrawIdx)c2); d->PrimWriteIdx((ImDrawIdx)a), d->PrimWriteIdx((ImDrawIdx)c2), d->PrimWriteIdx((ImDrawIdx)e); } } /// A soft light: alpha a at the middle, falling to nothing at the radii inline void glow(ImDrawList* d, ImVec2 m, float rx, float ry, unsigned rgb, float a) { static const float rr[8] = {0, 0.12f, 0.25f, 0.4f, 0.55f, 0.7f, 0.85f, 1}; float aa[8]; for (int i = 0; i < 8; i++) aa[i] = a * (1 - rr[i]) * (1 - rr[i]) * (1 + 0.5f * rr[i]); radial(d, m, rx, ry, rgb, rr, aa, 8); } /// A grid over a rectangle, alpha(x, y) asked at each corner (x and y from 0 to 1): the vignette, the gleam template inline void grid(ImDrawList* d, ImVec2 a, ImVec2 b, int nx, int ny, unsigned rgb, bool textured, F alpha) { const ImVec2 white = d->_Data->TexUvWhitePixel; d->PrimReserve(nx * ny * 6, (nx + 1) * (ny + 1)); const unsigned base = d->_VtxCurrentIdx; for (int y = 0; y <= ny; y++) for (int x = 0; x <= nx; x++) { const float fx = (float)x / nx, fy = (float)y / ny; d->PrimWriteVtx(ImVec2(lerp(a.x, b.x, fx), lerp(a.y, b.y, fy)), textured ? ImVec2(fx, fy) : white, ink(rgb, alpha(fx, fy))); } for (int y = 0; y < ny; y++) for (int x = 0; x < nx; x++) { const unsigned i = base + y * (nx + 1) + x; d->PrimWriteIdx((ImDrawIdx)i), d->PrimWriteIdx((ImDrawIdx)(i + 1)), d->PrimWriteIdx((ImDrawIdx)(i + nx + 2)); d->PrimWriteIdx((ImDrawIdx)i), d->PrimWriteIdx((ImDrawIdx)(i + nx + 2)), d->PrimWriteIdx((ImDrawIdx)(i + nx + 1)); } } /// A horizontal piece of light on a line: nothing at x0 and x1, a at the middle inline void streak(ImDrawList* d, float x0, float x1, float y0, float y1, unsigned rgb, float a) { const float m = (x0 + x1) * 0.5f; const ImU32 on = light(rgb, a), off = light(rgb, 0); d->AddRectFilledMultiColor(ImVec2(x0, y0), ImVec2(m, y1), off, on, on, off); d->AddRectFilledMultiColor(ImVec2(m, y0), ImVec2(x1, y1), on, off, off, on); } // ---- type: letters set one by one, so they can be spaced, their digits kept in equal slots, and shaded down their height ---- struct Shade { // (stops down the letters, from y0 to y1) float y0 = 0, y1 = 1; int n = 0; float at[4] = {}; unsigned rgb[4] = {}; ImU32 colour(float y, int alpha) const { const float t = clamp01((y - y0) / (y1 - y0)); int i = 0; while (i + 2 < n && t > at[i + 1]) i++; const float k = clamp01((t - at[i]) / std::max(1e-6f, at[i + 1] - at[i])); const int r = (int)lerp((float)(rgb[i] >> 16 & 255), (float)(rgb[i + 1] >> 16 & 255), k), g = (int)lerp((float)(rgb[i] >> 8 & 255), (float)(rgb[i + 1] >> 8 & 255), k), b = (int)lerp((float)(rgb[i] & 255), (float)(rgb[i + 1] & 255), k); return IM_COL32(r, g, b, alpha); } }; /// text at p (its top left); its width. track: pixels after each letter; slots: every digit as wide as the widest, centred in /// its slot (a count that changes does not shake); draw false: measured only; shade: its colours, col's alpha inline float type(ImDrawList* d, ImFont* font, float px, ImVec2 p, const char* text, ImU32 col, float track = 0, bool slots = false, bool draw = true, const Shade* shade = nullptr) { ImFontBaked* baked = font->GetFontBaked(px); const float scale = px / baked->Size; const char* end = text + strlen(text); float slot = 0; if (slots) for (ImWchar ch = '0'; ch <= '9'; ch++) slot = std::max(slot, baked->FindGlyph(ch)->AdvanceX * scale); int count = 0; for (const char* s = text; s < end;) { // (every glyph baked first: one baked later may move the earlier ones in the atlas) unsigned int ch = (unsigned char)*s; s += ch < 0x80 ? 1 : ImTextCharFromUtf8(&ch, s, end); baked->FindGlyph((ImWchar)ch); count++; } const float x0 = std::floor(p.x), y = std::floor(p.y); float x = x0; for (const char* s = text; s < end;) { unsigned int ch = (unsigned char)*s; s += ch < 0x80 ? 1 : ImTextCharFromUtf8(&ch, s, end); const ImFontGlyph* g = baked->FindGlyph((ImWchar)ch); float adv = g->AdvanceX * scale, gx = x; if (slots && ch >= '0' && ch <= '9') gx = std::floor(x + (slot - adv) * 0.5f + 0.5f), adv = slot; if (draw && g->Visible) { const float ax = gx + g->X0 * scale, ay = y + g->Y0 * scale, bx = gx + g->X1 * scale, by = y + g->Y1 * scale; if (!shade) { d->PrimReserve(6, 4); d->PrimRectUV(ImVec2(ax, ay), ImVec2(bx, by), ImVec2(g->U0, g->V0), ImVec2(g->U1, g->V1), col); } else { // (cut at each stop inside the glyph: a quad has one colour a corner) float cut[8]; int n = 0; cut[n++] = ay; for (int i = 0; i < shade->n; i++) { const float sy = lerp(shade->y0, shade->y1, shade->at[i]); if (sy > ay + 0.01f && sy < by - 0.01f) cut[n++] = sy; } cut[n++] = by; const int alpha = (int)(col >> IM_COL32_A_SHIFT & 255); for (int i = 0; i + 1 < n; i++) { const float va = lerp(g->V0, g->V1, (cut[i] - ay) / (by - ay)), vb = lerp(g->V0, g->V1, (cut[i + 1] - ay) / (by - ay)); const ImU32 ca = shade->colour(cut[i], alpha), cb = shade->colour(cut[i + 1], alpha); d->PrimReserve(6, 4); const unsigned base = d->_VtxCurrentIdx; d->PrimWriteIdx((ImDrawIdx)base), d->PrimWriteIdx((ImDrawIdx)(base + 1)), d->PrimWriteIdx((ImDrawIdx)(base + 2)); d->PrimWriteIdx((ImDrawIdx)base), d->PrimWriteIdx((ImDrawIdx)(base + 2)), d->PrimWriteIdx((ImDrawIdx)(base + 3)); d->PrimWriteVtx(ImVec2(ax, cut[i]), ImVec2(g->U0, va), ca), d->PrimWriteVtx(ImVec2(bx, cut[i]), ImVec2(g->U1, va), ca); d->PrimWriteVtx(ImVec2(bx, cut[i + 1]), ImVec2(g->U1, vb), cb), d->PrimWriteVtx(ImVec2(ax, cut[i + 1]), ImVec2(g->U0, vb), cb); } } } x += adv + track; } return count ? x - x0 - track : 0; } /// The top to draw at for a baseline at y inline float top_of(ImFont* font, float px, float baseline) { return baseline - font->GetFontBaked(px)->Ascent * (px / font->GetFontBaked(px)->Size); } // ---- what moves: kept from one drawing to the next (the presenting thread alone draws) ---- struct Motion { double first = -1, last = 0; double info_at = -1; // (when the lower part first showed) std::string title; // (the step shown: a new one fades in, its line from nothing) double title_at = -1; float fill = 0; bool lit[3] = {}; double ignite[3] = {-1e9, -1e9, -1e9}, last_ignite = -1e9; float kindle[3] = {}; double gleam_at = -1e9; bool gleamed_open = false, gleamed_lit = false; }; inline Motion motion; /// A block arriving at `at`: its alpha, and in *rise how far under its place it still is (12 points, 320 ms) inline float arrive(double now, double at, float u, float* rise) { const float t = ease_out((float)((now - at) / 0.32)); if (rise) *rise = (1 - t) * 12 * u; return now < at ? 0 : t; } /// The whole screen for view v at time now (seconds, any steady clock); fade, 0 to 1, takes it to black as it ends inline void draw(ui::Ctx& c, const StartupView& v, float fade, double now) { ImDrawList* d = c.d; const float w = c.w, h = c.h; Motion& m = motion; if (fade >= 1.5f) art_release(); // (vk_main.cpp: the last picture) if (art.released) { // (the game takes over: black, nothing of ours) d->AddRectFilled(ImVec2(0, 0), ImVec2(w, h), hex(0)); return; } art_make(); if (m.first < 0) m.first = m.last = now; const float dt = (float)std::clamp(now - m.last, 0.0, 0.25); m.last = now; blend_power = v.linear ? 2.2f : 1.0f; // (the tokens' pixel: of a 640-line window, the overlay's own size setting kept; smaller where the window is too // narrow or too low for the column) float u = c.s * 1.125f; u = std::min(u, std::min((w - 2 * c.safe) / 430.0f, (h - 2 * c.safe) / 484.0f)); const float cx = std::floor(w * 0.5f), hair = std::max(1.0f, std::floor(u + 0.5f)); const float crest_h = 180, stack = (crest_h + 210) * u, top = std::floor(std::max(c.safe, (h - stack) * 0.5f - 18 * u)); // (the crest: 28% of the window's height at the usual size, never above its own pixels) float ch = crest_h * u, cw = art.h ? ch * art.w / art.h : ch * 1.094f; if (art.w && cw > art.w) cw = (float)art.w, ch = (float)art.h; const ImVec2 ca(std::floor(cx - cw * 0.5f), std::floor(top + (crest_h * u - ch) * 0.5f)), cb(ca.x + cw, ca.y + ch), cm((ca.x + cb.x) * 0.5f, (ca.y + cb.y) * 0.5f); const float in0 = arrive(now, m.first, u, nullptr); // (the hall and the crest as the window opens) // ---- the hall ---- d->AddRectFilled(ImVec2(0, 0), ImVec2(w, h), hex(kInk900)); d->AddRectFilledMultiColor(ImVec2(0, 0), ImVec2(w, h * 0.45f), light(kTopLight, 0.045f), light(kTopLight, 0.045f), light(kTopLight, 0), light(kTopLight, 0)); { // (the halo behind the crest, breathing) static const float rr[7] = {0, 0.15f, 0.30f, 0.45f, 0.62f, 0.80f, 1}; static const float aa[7] = {0.22f, 0.17f, 0.12f, 0.07f, 0.046f, 0.022f, 0}; const float k = in0 * breath(now, 6.0f, 0.80f) * (v.closing ? 0.6f : 1.0f); radial(d, cm, cw * 1.15f, cw * 1.15f, kGold500, rr, aa, 7, k); } { // (the vignette: nothing until 55% of the way to a corner, then to 0.55 black) const float half = std::sqrt(w * w + h * h) * 0.5f; grid(d, ImVec2(0, 0), ImVec2(w, h), 32, 18, 0x000000, false, [&](float fx, float fy) { const float dx = (fx - 0.5f) * w, dy = (fy - 0.5f) * h, t = clamp01((std::sqrt(dx * dx + dy * dy) / half - 0.55f) / 0.45f); return 0.55f * t * t * (3 - 2 * t); }); } if (art.grain) { // (grain, a texel a pixel) d->PushTexture(art.grain->GetTexRef()); const ImU32 col = light(0xFFFFFF, 0.025f); for (float y = 0; y < h; y += 256) for (float x = 0; x < w; x += 256) { const float x1 = std::min(x + 256, w), y1 = std::min(y + 256, h); d->PrimReserve(6, 4); d->PrimRectUV(ImVec2(x, y), ImVec2(x1, y1), ImVec2(0, 0), ImVec2((x1 - x) / 256, (y1 - y) / 256), col); } d->PopTexture(); } for (int i = 0; i < 26; i++) { // (motes: specks of light rising through the stage, born and fading inside it) uint32_t s = (uint32_t)i * 2654435761u + 0x9E3779B9u; const auto rnd = [&s] { s ^= s << 13, s ^= s >> 17, s ^= s << 5; return (s & 0xFFFFFF) / 16777216.0f; }; const float life = lerp(9, 17, rnd()), phase = rnd(), x0 = lerp(-1.25f, 1.25f, rnd()), y0 = lerp(-0.25f, 0.75f, rnd()), speed = lerp(6, 14, rnd()), size = lerp(1.0f, 2.5f, rnd()), alpha = lerp(0.10f, 0.45f, rnd()), sway = lerp(0.3f, 0.7f, rnd()); const float t = (float)std::fmod(now / life + phase, 1.0), age = t * life; const ImVec2 p(cm.x + x0 * cw + std::sin((float)now * sway + phase * 6.28f) * 7 * u, cm.y + y0 * ch + 0.5f * ch - age * speed * u); const float a = alpha * std::sin(t * 3.14159265f) * in0 * (v.closing ? 0.4f : 1.0f); d->AddCircleFilled(p, std::max(0.8f, size * u * 0.5f), light(kGold100, a), 8); } // ---- the crest and its stones ---- glow(d, ImVec2(cm.x, cb.y + 5 * u), cw * 0.46f, ch * 0.075f, kGold500, 0.18f * in0); // (the light on the floor under it) const float gone = v.closing ? 0.55f : 1.0f; // (closing: the light goes down) if (art.dim) { d->AddImage(art.dim->GetTexRef(), ca, cb, ImVec2(0, 0), ImVec2(1, 1), ink(0xFFFFFF, in0)); float done_a[3] = {}; for (int k = 0; k < 3; k++) { // (the last one a little before the end, 99% of the last part: lit, it is seen before the screen fades) const bool want = !v.closing && (v.done || v.stones >= (k == 2 ? 2.93 : k + 1.0)); if (want && !m.lit[k]) { m.lit[k] = true; // (lit as the screen opens, a start with nothing to prepare: it is so, and comes out of the dark with the crest; // nothing ignites. Such a start can be over in 0.7 s (measured): three stones igniting one after the other were // cut off at the second. Later: not before the crest is there, and two at once one after the other) if (now - m.first < 0.12) m.ignite[k] = now - 10; else m.last_ignite = m.ignite[k] = std::max(std::max(now, m.first + 0.35), m.last_ignite + 0.22); } const float target = clamp01((float)v.stones - k) * 0.30f; m.kindle[k] += (target - m.kindle[k]) * (1 - std::exp(-dt / 0.35f)); const float since = (float)(now - m.ignite[k]); const float on = m.lit[k] && since >= 0 ? ease_out(since / 0.6f) : 0; const float a = std::max(m.kindle[k] * breath(now, 3.2f, 0.72f, k / 3.0f), on); done_a[k] = on; if (a > 0.004f && art.stone[k]) d->AddImage(art.stone[k]->GetTexRef(), ca, cb, ImVec2(0, 0), ImVec2(1, 1), ink(0xFFFFFF, a * in0 * gone)); } for (int k = 0; k < 3; k++) { // (the light the stones throw: over the crest) const ImVec2 at(lerp(ca.x, cb.x, kStoneAt[k][0]), lerp(ca.y, cb.y, kStoneAt[k][1])); const float since = (float)(now - m.ignite[k]); if (done_a[k] > 0) glow(d, at, cw * 0.22f, cw * 0.22f, kStoneGlow[k], 0.16f * done_a[k] * breath(now, 4.5f, 0.6f, k / 3.0f) * in0 * gone); else if (m.kindle[k] > 0.004f) glow(d, at, cw * 0.16f, cw * 0.16f, kStoneGlow[k], 0.10f * (m.kindle[k] / 0.30f) * breath(now, 3.2f, 0.72f, k / 3.0f) * in0 * gone); if (m.lit[k] && since >= 0 && since < 0.9f) { // (the bloom as it ignites) const float t = since / 0.9f, r = cw * lerp(0.45f, 0.90f, ease_out(t)); glow(d, at, r, r, kStoneGlow[k], 0.55f * (1 - t) * (1 - t) * in0); } } // (the gleam: once when all three are lit; and over the dark crest of a start that has work to do, a second in) if (!m.gleamed_open && now - m.first > 1.2) { m.gleamed_open = true; if (!m.lit[0]) m.gleam_at = now; } if (m.lit[0] && m.lit[1] && m.lit[2] && !m.gleamed_lit) m.gleamed_lit = true, m.gleam_at = std::max(std::max(now, m.ignite[2] + 0.35), m.first + 0.45); const float gt = (float)((now - m.gleam_at) / 1.1); if (gt > 0 && gt < 1 && art.shape && !v.closing) { const float slant = 0.577f * ch / cw, half = 0.11f, mid = lerp(-half - slant * 0.5f, 1 + half + slant * 0.5f, ease_io(gt)); d->PushTexture(art.shape->GetTexRef()); grid(d, ca, cb, 40, 12, kGold100, true, [&](float fx, float fy) { const float q = (fx + (0.5f - fy) * slant - mid) / half; return q <= -1 || q >= 1 ? 0.0f : 0.35f * (1 - q * q) * (1 - q * q) * in0 * (blend_power != 1 ? 0.45f : 1.0f); }); d->PopTexture(); } } // ---- the wordmark ---- { float rise = 0; const float a = arrive(now, m.first + 0.045, u, &rise), px = 25 * u, track = 0.40f * px; const float tw = type(d, c.f.heading, px, ImVec2(), "TRIFORCE", 0, track, false, false); const float base = top + (crest_h + 22) * u + 0.74f * px + rise; Shade sh; sh.y0 = base - 0.72f * px, sh.y1 = base + 0.02f * px, sh.n = 4; const float at[4] = {0, 0.42f, 0.56f, 1}; const unsigned rgb[4] = {0xFFF1B8, 0xE8B840, 0xB57E1C, 0xF3CF6A}; memcpy(sh.at, at, sizeof at), memcpy(sh.rgb, rgb, sizeof rgb); type(d, c.f.heading, px, ImVec2(cx - tw * 0.5f, top_of(c.f.heading, px, base)), "TRIFORCE", ink(0xFFFFFF, a * (v.closing ? 0.7f : 1.0f)), track, false, true, &sh); } // ---- the lower part: the step, how far, the line, what it is ---- const float col_w = std::floor(std::min(w - 2 * c.safe - 8 * u, std::max(w * 0.38f, 420 * u))); const float x0 = std::floor(cx - col_w * 0.5f), x1 = x0 + col_w; if (!v.title.empty()) { if (m.info_at < 0) m.info_at = now; // (a new step, or the same step's next pass (the noted pipelines after the predicted ones: the same title, another // sentence, the count from 0 again): it fades in, and its line starts from nothing. Seen in the game without this: the // line ran backwards from full under "0%") const std::string step = v.title + "\n" + v.detail; if (m.title != step) { m.title = step, m.title_at = now; m.fill = v.done ? m.fill : 0; } const float change = m.title_at > m.info_at ? ease_out((float)((now - m.title_at) / 0.22)) : 1; float rise[4]; float a[4]; for (int i = 0; i < 4; i++) a[i] = arrive(now, m.info_at + 0.045 * i, u, &rise[i]); const float y_eye = top + (crest_h + 102) * u, y_num = top + (crest_h + 168) * u, y_line = std::floor(top + (crest_h + 184) * u), y_text = y_line + 13 * u; { // (the eyebrow: a hairline, then the step in spaced capitals) std::string label = v.step.empty() ? "" : v.step + " \xC2\xB7 "; for (char ch2 : v.title) label += (char)toupper((unsigned char)ch2); const float px = 10.5f * u, y = y_eye + rise[0], aa = a[0] * change; d->AddRectFilled(ImVec2(x0, std::floor(y)), ImVec2(x0 + 20 * u, std::floor(y) + hair), ink(kGold500, 0.28f * 2.0f * aa)); type(d, c.f.strong, px, ImVec2(x0 + 30 * u, ui::mid_top(c.f.strong, px, y + hair * 0.5f)), label.c_str(), ink(kGold500, aa), 0.22f * px); } const float base = y_num + rise[1]; if (!v.pct.empty()) { // (the percentage: the figures large, its sign small and gold) std::string digits = v.pct; if (!digits.empty() && digits.back() == '%') digits.pop_back(); const float px = 64 * u, aa = a[1] * change; const float nw = type(d, c.f.heading, px, ImVec2(x0 - 2 * u, top_of(c.f.heading, px, base)), digits.c_str(), ink(kTextHi, aa), 0, true); type(d, c.f.heading, 24 * u, ImVec2(x0 - 2 * u + nw + 5 * u, top_of(c.f.heading, 24 * u, base)), "%", ink(kGold500, aa)); } if (v.pct.empty() && !v.left.empty()) { // (nothing counted: what is being done, in the figures' place, a quiet title) const float px = 30 * u; type(d, c.f.heading, px, ImVec2(x0, top_of(c.f.heading, px, base - 6 * u)), v.left.c_str(), ink(kTextHi, a[1] * change)); } else { // (the detail, set to the right: the count over the time left, or one of them on the figures' line) const float px = 12.5f * u, aa = a[1] * change; const bool two = !v.left.empty() && !v.right.empty(); const auto right = [&](const std::string& t, float baseline, unsigned rgb) { if (t.empty()) return; const float tw = type(d, c.f.body, px, ImVec2(), t.c_str(), 0, 0, true, false); type(d, c.f.body, px, ImVec2(x1 - tw, top_of(c.f.body, px, baseline)), t.c_str(), ink(rgb, aa), 0, true); }; right(v.left, two ? base - 19 * u : base, kText); right(v.right, base, kTextDim); } { // (the line) const float y = y_line + rise[2], aa = a[2], th = std::max(2.0f, std::floor(2 * u + 0.5f)); d->AddRectFilled(ImVec2(x0, y), ImVec2(x1, y + th), ink(kInk600, aa)); if (v.fraction >= 0) { const float target = (float)std::min(v.fraction, 1.0); m.fill += (target - m.fill) * (1 - std::exp(-dt / 0.10f)); // (never a jump: there in 300 ms) if (std::fabs(target - m.fill) < 0.0004f) m.fill = target; const float fx = x0 + col_w * m.fill, fa = aa * change; if (fx > x0 + 0.5f) { const float gl = 8 * u; // (the glow under the fill) d->AddRectFilledMultiColor(ImVec2(x0, y - gl), ImVec2(fx, y + th * 0.5f), light(kGold500, 0), light(kGold500, 0), light(kGold500, 0.30f * fa), light(kGold500, 0.30f * fa)); d->AddRectFilledMultiColor(ImVec2(x0, y + th * 0.5f), ImVec2(fx, y + th + gl), light(kGold500, 0.30f * fa), light(kGold500, 0.30f * fa), light(kGold500, 0), light(kGold500, 0)); d->AddRectFilledMultiColor(ImVec2(x0, y), ImVec2(fx, y + th), ink(kGold500, fa), ink(kGold300, fa), ink(kGold300, fa), ink(kGold500, fa)); // (a glint along what is filled, every 2.4 s: the screen is alive while a count stands still) const float gt = (float)std::fmod(now, 2.4) / 1.5f, len = 70 * u; if (gt < 1 && fx - x0 > len * 0.6f && !v.done) { const float gx = lerp(x0 - len, fx, ease_io(gt)); d->PushClipRect(ImVec2(x0, y - 2 * u), ImVec2(fx, y + th + 2 * u), true); streak(d, gx, gx + len, y, y + th, kGold100, 0.9f * fa); d->PopClipRect(); } // (the spark at its head: a small diamond in its own light) glow(d, ImVec2(fx, y + th * 0.5f), 11 * u, 11 * u, kGold300, 0.50f * fa); ui::diamond(c, ImVec2(fx, y + th * 0.5f), 3.5f * u, ink(kGold100, fa)); } } else if (v.busy || v.closing) { // (no count: a piece of the line goes across, 1.6 s each time) const float t = ease_io((float)std::fmod(now, 1.6) / 1.6f), len = col_w * 0.28f, sx = lerp(x0 - len, x1, t); d->PushClipRect(ImVec2(x0, y - 9 * u), ImVec2(x1, y + th + 9 * u), true); streak(d, sx, sx + len, y, y + th, kGold500, (v.closing ? 0.55f : 1.0f) * aa); d->PopClipRect(); } } if (!v.detail.empty()) ui::para(c, c.f.body, 12.5f * u, ImVec2(x0, y_text + rise[3]), ink(kTextDim, a[3] * change), v.detail.c_str(), col_w); } // ---- the foot: one line of what to know, the build and the graphics card in the corners ---- { const float px = 12.5f * u, y = h - c.safe - px - 6 * u, a = arrive(now, m.first + 0.2, u, nullptr); if (!v.hint.empty() && m.info_at >= 0) { const float ha = arrive(now, m.info_at + 0.25, u, nullptr); const float tw = ui::size_of(c.f.body, px, v.hint.c_str()).x; if (tw <= w - 2 * c.safe) ui::text(c, c.f.body, px, ImVec2(std::floor(cx - tw * 0.5f), y), ink(kTextDim, ha), v.hint.c_str()); else ui::para(c, c.f.body, px, ImVec2(c.safe, y - px * 1.3f), ink(kTextDim, ha), v.hint.c_str(), w - 2 * c.safe); } // (the corners on the hint's line while both have room beside it, else a line above it) const float side = c.safe + 6 * u, hint_w = v.hint.empty() || m.info_at < 0 ? 0 : ui::size_of(c.f.body, px, v.hint.c_str()).x; const float corner_w = std::max(ui::size_of(c.f.body, px, v.version.c_str()).x, ui::size_of(c.f.body, px, v.device.c_str()).x); const float yy = hint_w * 0.5f + 40 * u + corner_w + side < w * 0.5f ? y : y - 24 * u; if (!v.version.empty()) ui::text(c, c.f.body, px, ImVec2(side, yy), ink(kTextFaint, a), v.version.c_str()); if (!v.device.empty()) { const float tw = ui::size_of(c.f.body, px, v.device.c_str()).x; if (tw < w * 0.5f - side) ui::text(c, c.f.body, px, ImVec2(w - side - tw, yy), ink(kTextFaint, a), v.device.c_str()); } } if (fade > 0) d->AddRectFilled(ImVec2(0, 0), ImVec2(w, h), ink(0x000000, fade)); // (the end: to black, the game's first frame next) } /// The clock draw goes by in the game inline double clock_now() { return std::chrono::duration(std::chrono::steady_clock::now().time_since_epoch()).count(); } } // namespace mkwvk::start_screen